Version 2.18.0-126.0.dev
Merge commit 'd9152974edc3a04ff706db50bf721e2701acbd53' into 'dev'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a3cc15..b412795 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -39,7 +39,19 @@
It can still be created with the `--legacy-packages-file` flag.
* `dart pub outdated` now shows which of your dependencies are discontinued.
-## 2.17.0
+## 2.17.1 - 2022-05-18
+
+This is a patch release that fixes:
+
+- an analyzer plugin crash (issue [#48682][]).
+- Dart FFI support for `late` `Finalizable` variables (issue [#49024]).
+- `dart compile` on macOS 10.15 (issue [#49010][]).
+
+[#48682]: https://github.com/dart-lang/sdk/issues/48682
+[#49024]: https://github.com/dart-lang/sdk/issues/49024
+[#49010]: https://github.com/dart-lang/sdk/issues/49010
+
+## 2.17.0 - 2022-05-11
### Language
diff --git a/DEPS b/DEPS
index 1a1424f1..793556f 100644
--- a/DEPS
+++ b/DEPS
@@ -42,8 +42,7 @@
"sdk_tag": "version:2.17.0",
# co19 is a cipd package. Use update.sh in tests/co19[_2] to update these
- # hashes. It requires access to the dart-build-access group, which EngProd
- # has.
+ # hashes.
"co19_rev": "9849573cd1b8317e58247b8c1672e89b1cd842e2",
# This line prevents conflicts when both packages are rolled simultaneously.
"co19_2_rev": "b2034a17609472e374623f3dbe0efd9f5cb258af",
@@ -109,7 +108,7 @@
"dartdoc_rev": "334072b0cad436c05f6bcecf8a1a59f2f0809b84",
"devtools_rev": "3c16b8d73120e46958982d94215d499793b972eb",
- "ffi_rev": "4dd32429880a57b64edaf54c9d5af8a9fa9a4ffb",
+ "ffi_rev": "0c8364a728cfe4e4ba859c53b99d56b3dbe3add4",
"file_rev": "0132eeedea2933513bf230513a766a8baeab0c4f",
"fixnum_rev": "3bfc2ed1eea7e7acb79ad4f17392f92c816fc5ce",
"glob_rev": "e10eb2407c58427144004458ef85c9bbf7286e56",
diff --git a/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_call_counts.dart b/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_call_counts.dart
new file mode 100644
index 0000000..ec1695f
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_call_counts.dart
@@ -0,0 +1,116 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/exhaustive.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/profile.dart' as profile;
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+
+import '../../test/exhaustiveness/utils.dart';
+
+void main() {
+ profile.enabled = true;
+
+ // (A)
+ // /|\
+ // B C D
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var t = StaticType('T', fields: {'w': a, 'x': a, 'y': a, 'z': a});
+
+ expectExhaustiveOnlyAll(t, [
+ {'w': b, 'x': b, 'y': b, 'z': b},
+ {'w': b, 'x': b, 'y': b, 'z': c},
+ {'w': b, 'x': b, 'y': b, 'z': d},
+ {'w': b, 'x': b, 'y': c, 'z': b},
+ {'w': b, 'x': b, 'y': c, 'z': c},
+ {'w': b, 'x': b, 'y': c, 'z': d},
+ {'w': b, 'x': b, 'y': d, 'z': b},
+ {'w': b, 'x': b, 'y': d, 'z': c},
+ {'w': b, 'x': b, 'y': d, 'z': d},
+ {'w': b, 'x': c, 'y': b, 'z': b},
+ {'w': b, 'x': c, 'y': b, 'z': c},
+ {'w': b, 'x': c, 'y': b, 'z': d},
+ {'w': b, 'x': c, 'y': c, 'z': b},
+ {'w': b, 'x': c, 'y': c, 'z': c},
+ {'w': b, 'x': c, 'y': c, 'z': d},
+ {'w': b, 'x': c, 'y': d, 'z': b},
+ {'w': b, 'x': c, 'y': d, 'z': c},
+ {'w': b, 'x': c, 'y': d, 'z': d},
+ {'w': b, 'x': d, 'y': b, 'z': b},
+ {'w': b, 'x': d, 'y': b, 'z': c},
+ {'w': b, 'x': d, 'y': b, 'z': d},
+ {'w': b, 'x': d, 'y': c, 'z': b},
+ {'w': b, 'x': d, 'y': c, 'z': c},
+ {'w': b, 'x': d, 'y': c, 'z': d},
+ {'w': b, 'x': d, 'y': d, 'z': b},
+ {'w': b, 'x': d, 'y': d, 'z': c},
+ {'w': b, 'x': d, 'y': d, 'z': d},
+ {'w': c, 'x': b, 'y': b, 'z': b},
+ {'w': c, 'x': b, 'y': b, 'z': c},
+ {'w': c, 'x': b, 'y': b, 'z': d},
+ {'w': c, 'x': b, 'y': c, 'z': b},
+ {'w': c, 'x': b, 'y': c, 'z': c},
+ {'w': c, 'x': b, 'y': c, 'z': d},
+ {'w': c, 'x': b, 'y': d, 'z': b},
+ {'w': c, 'x': b, 'y': d, 'z': c},
+ {'w': c, 'x': b, 'y': d, 'z': d},
+ {'w': c, 'x': c, 'y': b, 'z': b},
+ {'w': c, 'x': c, 'y': b, 'z': c},
+ {'w': c, 'x': c, 'y': b, 'z': d},
+ {'w': c, 'x': c, 'y': c, 'z': b},
+ {'w': c, 'x': c, 'y': c, 'z': c},
+ {'w': c, 'x': c, 'y': c, 'z': d},
+ {'w': c, 'x': c, 'y': d, 'z': b},
+ {'w': c, 'x': c, 'y': d, 'z': c},
+ {'w': c, 'x': c, 'y': d, 'z': d},
+ {'w': c, 'x': d, 'y': b, 'z': b},
+ {'w': c, 'x': d, 'y': b, 'z': c},
+ {'w': c, 'x': d, 'y': b, 'z': d},
+ {'w': c, 'x': d, 'y': c, 'z': b},
+ {'w': c, 'x': d, 'y': c, 'z': c},
+ {'w': c, 'x': d, 'y': c, 'z': d},
+ {'w': c, 'x': d, 'y': d, 'z': b},
+ {'w': c, 'x': d, 'y': d, 'z': c},
+ {'w': c, 'x': d, 'y': d, 'z': d},
+ {'w': d, 'x': b, 'y': b, 'z': b},
+ {'w': d, 'x': b, 'y': b, 'z': c},
+ {'w': d, 'x': b, 'y': b, 'z': d},
+ {'w': d, 'x': b, 'y': c, 'z': b},
+ {'w': d, 'x': b, 'y': c, 'z': c},
+ {'w': d, 'x': b, 'y': c, 'z': d},
+ {'w': d, 'x': b, 'y': d, 'z': b},
+ {'w': d, 'x': b, 'y': d, 'z': c},
+ {'w': d, 'x': b, 'y': d, 'z': d},
+ {'w': d, 'x': c, 'y': b, 'z': b},
+ {'w': d, 'x': c, 'y': b, 'z': c},
+ {'w': d, 'x': c, 'y': b, 'z': d},
+ {'w': d, 'x': c, 'y': c, 'z': b},
+ {'w': d, 'x': c, 'y': c, 'z': c},
+ {'w': d, 'x': c, 'y': c, 'z': d},
+ {'w': d, 'x': c, 'y': d, 'z': b},
+ {'w': d, 'x': c, 'y': d, 'z': c},
+ {'w': d, 'x': c, 'y': d, 'z': d},
+ {'w': d, 'x': d, 'y': b, 'z': b},
+ {'w': d, 'x': d, 'y': b, 'z': c},
+ {'w': d, 'x': d, 'y': b, 'z': d},
+ {'w': d, 'x': d, 'y': c, 'z': b},
+ {'w': d, 'x': d, 'y': c, 'z': c},
+ {'w': d, 'x': d, 'y': c, 'z': d},
+ {'w': d, 'x': d, 'y': d, 'z': b},
+ {'w': d, 'x': d, 'y': d, 'z': c},
+ {'w': d, 'x': d, 'y': d, 'z': d},
+ ]);
+}
+
+/// Test that [cases] are exhaustive over [type] if and only if all cases are
+/// included and that all subsets of the cases are not exhaustive.
+void expectExhaustiveOnlyAll(StaticType type, List<Object> cases) {
+ var spaces = parseSpaces(cases);
+ profile.reset();
+ print(isExhaustive(Space(type), spaces));
+ profile.log();
+}
diff --git a/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_timed.dart b/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_timed.dart
new file mode 100644
index 0000000..ae2b282
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_timed.dart
@@ -0,0 +1,128 @@
+// Copyright (c) 2022, 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.
+
+import 'dart:math';
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/exhaustive.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+
+import '../../test/exhaustiveness/utils.dart';
+
+void main() {
+ // (A)
+ // /|\
+ // B C D
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var t = StaticType('T', fields: {'w': a, 'x': a, 'y': a, 'z': a});
+
+ expectExhaustiveOnlyAll(t, [
+ {'w': b, 'x': b, 'y': b, 'z': b},
+ {'w': b, 'x': b, 'y': b, 'z': c},
+ {'w': b, 'x': b, 'y': b, 'z': d},
+ {'w': b, 'x': b, 'y': c, 'z': b},
+ {'w': b, 'x': b, 'y': c, 'z': c},
+ {'w': b, 'x': b, 'y': c, 'z': d},
+ {'w': b, 'x': b, 'y': d, 'z': b},
+ {'w': b, 'x': b, 'y': d, 'z': c},
+ {'w': b, 'x': b, 'y': d, 'z': d},
+ {'w': b, 'x': c, 'y': b, 'z': b},
+ {'w': b, 'x': c, 'y': b, 'z': c},
+ {'w': b, 'x': c, 'y': b, 'z': d},
+ {'w': b, 'x': c, 'y': c, 'z': b},
+ {'w': b, 'x': c, 'y': c, 'z': c},
+ {'w': b, 'x': c, 'y': c, 'z': d},
+ {'w': b, 'x': c, 'y': d, 'z': b},
+ {'w': b, 'x': c, 'y': d, 'z': c},
+ {'w': b, 'x': c, 'y': d, 'z': d},
+ {'w': b, 'x': d, 'y': b, 'z': b},
+ {'w': b, 'x': d, 'y': b, 'z': c},
+ {'w': b, 'x': d, 'y': b, 'z': d},
+ {'w': b, 'x': d, 'y': c, 'z': b},
+ {'w': b, 'x': d, 'y': c, 'z': c},
+ {'w': b, 'x': d, 'y': c, 'z': d},
+ {'w': b, 'x': d, 'y': d, 'z': b},
+ {'w': b, 'x': d, 'y': d, 'z': c},
+ {'w': b, 'x': d, 'y': d, 'z': d},
+ {'w': c, 'x': b, 'y': b, 'z': b},
+ {'w': c, 'x': b, 'y': b, 'z': c},
+ {'w': c, 'x': b, 'y': b, 'z': d},
+ {'w': c, 'x': b, 'y': c, 'z': b},
+ {'w': c, 'x': b, 'y': c, 'z': c},
+ {'w': c, 'x': b, 'y': c, 'z': d},
+ {'w': c, 'x': b, 'y': d, 'z': b},
+ {'w': c, 'x': b, 'y': d, 'z': c},
+ {'w': c, 'x': b, 'y': d, 'z': d},
+ {'w': c, 'x': c, 'y': b, 'z': b},
+ {'w': c, 'x': c, 'y': b, 'z': c},
+ {'w': c, 'x': c, 'y': b, 'z': d},
+ {'w': c, 'x': c, 'y': c, 'z': b},
+ {'w': c, 'x': c, 'y': c, 'z': c},
+ {'w': c, 'x': c, 'y': c, 'z': d},
+ {'w': c, 'x': c, 'y': d, 'z': b},
+ {'w': c, 'x': c, 'y': d, 'z': c},
+ {'w': c, 'x': c, 'y': d, 'z': d},
+ {'w': c, 'x': d, 'y': b, 'z': b},
+ {'w': c, 'x': d, 'y': b, 'z': c},
+ {'w': c, 'x': d, 'y': b, 'z': d},
+ {'w': c, 'x': d, 'y': c, 'z': b},
+ {'w': c, 'x': d, 'y': c, 'z': c},
+ {'w': c, 'x': d, 'y': c, 'z': d},
+ {'w': c, 'x': d, 'y': d, 'z': b},
+ {'w': c, 'x': d, 'y': d, 'z': c},
+ {'w': c, 'x': d, 'y': d, 'z': d},
+ {'w': d, 'x': b, 'y': b, 'z': b},
+ {'w': d, 'x': b, 'y': b, 'z': c},
+ {'w': d, 'x': b, 'y': b, 'z': d},
+ {'w': d, 'x': b, 'y': c, 'z': b},
+ {'w': d, 'x': b, 'y': c, 'z': c},
+ {'w': d, 'x': b, 'y': c, 'z': d},
+ {'w': d, 'x': b, 'y': d, 'z': b},
+ {'w': d, 'x': b, 'y': d, 'z': c},
+ {'w': d, 'x': b, 'y': d, 'z': d},
+ {'w': d, 'x': c, 'y': b, 'z': b},
+ {'w': d, 'x': c, 'y': b, 'z': c},
+ {'w': d, 'x': c, 'y': b, 'z': d},
+ {'w': d, 'x': c, 'y': c, 'z': b},
+ {'w': d, 'x': c, 'y': c, 'z': c},
+ {'w': d, 'x': c, 'y': c, 'z': d},
+ {'w': d, 'x': c, 'y': d, 'z': b},
+ {'w': d, 'x': c, 'y': d, 'z': c},
+ {'w': d, 'x': c, 'y': d, 'z': d},
+ {'w': d, 'x': d, 'y': b, 'z': b},
+ {'w': d, 'x': d, 'y': b, 'z': c},
+ {'w': d, 'x': d, 'y': b, 'z': d},
+ {'w': d, 'x': d, 'y': c, 'z': b},
+ {'w': d, 'x': d, 'y': c, 'z': c},
+ {'w': d, 'x': d, 'y': c, 'z': d},
+ {'w': d, 'x': d, 'y': d, 'z': b},
+ {'w': d, 'x': d, 'y': d, 'z': c},
+ {'w': d, 'x': d, 'y': d, 'z': d},
+ ]);
+}
+
+/// Test that [cases] are exhaustive over [type] if and only if all cases are
+/// included and that all subsets of the cases are not exhaustive.
+void expectExhaustiveOnlyAll(StaticType type, List<Object> cases) {
+ const trials = 100;
+
+ var best = 9999999;
+ for (var j = 0; j < 100000; j++) {
+ var watch = Stopwatch()..start();
+ for (var i = 0; i < trials; i++) {
+ var spaces = parseSpaces(cases);
+ var actual = isExhaustive(Space(type), spaces);
+ if (!actual) {
+ throw 'Expected exhaustive';
+ }
+ }
+
+ var elapsed = watch.elapsedMilliseconds;
+ best = min(elapsed, best);
+ print('${elapsed / trials}ms (best ${best / trials}ms)');
+ }
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/equal.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/equal.dart
new file mode 100644
index 0000000..63f527d
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/equal.dart
@@ -0,0 +1,71 @@
+// Copyright (c) 2022, 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.
+
+import 'profile.dart' as profile;
+import 'space.dart';
+
+/// Returns `true` if [left] and [right] are equivalent spaces.
+///
+/// Equality is defined purely structurally/syntactically.
+bool equal(Space left, Space right, String reason) {
+ profile.count('equal', reason);
+
+ if (identical(left, right)) return true;
+
+ // Empty is only equal to itself (and will get caught by the previous check).
+ if (left == Space.empty) return false;
+ if (right == Space.empty) return false;
+
+ if (left is UnionSpace && right is UnionSpace) {
+ return _equalUnions(left, right);
+ }
+
+ if (left is ExtractSpace && right is ExtractSpace) {
+ return _equalExtracts(left, right);
+ }
+
+ // If we get here, one is a union and one is an extract.
+ return false;
+}
+
+/// Returns `true` if [left] and [right] have the same type and the same fields
+/// with equal subspaces.
+bool _equalExtracts(ExtractSpace left, ExtractSpace right) {
+ // Must have the same type.
+ if (left.type != right.type) return false;
+
+ // And the same fields.
+ Set<String> fields = {...left.fields.keys, ...right.fields.keys};
+ if (left.fields.length != fields.length) return false;
+ if (right.fields.length != fields.length) return false;
+
+ for (String field in fields) {
+ if (!equal(left.fields[field]!, right.fields[field]!, 'recurse extract')) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/// Returns `true` if [left] and [right] contain equal arms in any order.
+///
+/// Assumes that all duplicates have already been removed from each union.
+bool _equalUnions(UnionSpace left, UnionSpace right) {
+ if (left.arms.length != right.arms.length) return false;
+
+ /// For each left arm, should find an equal right arm.
+ for (Space leftArm in left.arms) {
+ bool found = false;
+ for (Space rightArm in right.arms) {
+ if (equal(leftArm, rightArm, 'recurse union')) {
+ found = true;
+ break;
+ }
+ }
+ if (!found) return false;
+ }
+
+ return true;
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/exhaustive.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/exhaustive.dart
new file mode 100644
index 0000000..17fbf9f
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/exhaustive.dart
@@ -0,0 +1,49 @@
+// Copyright (c) 2022, 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.
+
+import 'space.dart';
+import 'static_type.dart';
+import 'subtract.dart';
+
+/// Returns `true` if [cases] exhaustively covers all possible values of
+/// [value].
+///
+/// This is defined simply in terms of subtraction and unions: [cases] is a
+/// union space, and it's exhaustive if subtracting it from [value] leaves
+/// nothing.
+bool isExhaustive(Space value, List<Space> cases) {
+ return subtract(value, new Space.union(cases)) == Space.empty;
+}
+
+/// Checks the [cases] representing a series of switch cases to see if they
+/// exhaustively cover all possible values of the matched [valueType]. Also
+/// checks to see if any case can't be matched because it's covered by previous
+/// cases.
+///
+/// Returns a string containing any unreachable case or non-exhaustive match
+/// errors. Returns an empty string if all cases are reachable and the cases
+/// are exhaustive.
+String reportErrors(StaticType valueType, List<Space> cases) {
+ List<String> errors = <String>[];
+
+ Space remaining = new Space(valueType);
+ for (int i = 0; i < cases.length; i++) {
+ // See if this case is covered by previous ones.
+ if (i > 0) {
+ Space previous = new Space.union(cases.sublist(0, i));
+ if (subtract(cases[i], previous) == Space.empty) {
+ errors.add('Case #${i + 1} ${cases[i]} is covered by $previous.');
+ }
+ }
+
+ remaining = subtract(remaining, cases[i]);
+ }
+
+ if (remaining != Space.empty) {
+ errors.add(
+ '$valueType is not exhaustively matched by ${new Space.union(cases)}.');
+ }
+
+ return errors.join('\n');
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect.dart
new file mode 100644
index 0000000..e710c60
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect.dart
@@ -0,0 +1,107 @@
+// Copyright (c) 2022, 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.
+
+import 'profile.dart' as profile;
+import 'space.dart';
+import 'static_type.dart';
+
+/// Calculates the intersection of [left] and [right].
+///
+/// This is used to tell if two field spaces on a pair of spaces being
+/// subtracted have no common values.
+Space intersect(Space left, Space right) {
+ profile.count('intersect');
+
+ // The intersection with an empty space is always empty.
+ if (left == Space.empty) return Space.empty;
+ if (right == Space.empty) return Space.empty;
+
+ // The intersection of a union is the union of the intersections of its arms.
+ if (left is UnionSpace) {
+ return new Space.union(
+ left.arms.map((arm) => intersect(arm, right)).toList());
+ }
+
+ if (right is UnionSpace) {
+ return new Space.union(
+ right.arms.map((arm) => intersect(left, arm)).toList());
+ }
+
+ // Otherwise, we're intersecting two [ExtractSpaces].
+ return _intersectExtracts(left as ExtractSpace, right as ExtractSpace);
+}
+
+/// Returns the intersection of two static types [left] and [right].
+///
+/// Returns `null` if the intersection is empty.
+StaticType? intersectTypes(StaticType left, StaticType right) {
+ // If one type is a subtype, the subtype is the intersection.
+ if (left.isSubtypeOf(right)) return left;
+ if (right.isSubtypeOf(left)) return right;
+
+ if (left.isNullable) {
+ if (right.isNullable) {
+ StaticType? intersection =
+ intersectTypes(left.underlying, right.underlying);
+ if (intersection == null) return null;
+ return intersection.nullable;
+ } else {
+ return intersectTypes(left.underlying, right);
+ }
+ } else if (right.isNullable) {
+ return intersectTypes(left, right.underlying);
+ }
+
+ // If we allow sealed types to share subtypes, then this will need to be more
+ // sophisticated. Here:
+ //
+ // (A) (B)
+ // / \ / \
+ // C D E
+ //
+ // The intersection of A and B should be D. Here:
+ //
+ // (A) (B)
+ // | \ / |
+ // |\ \/ /|
+ // | \/\/ |
+ // C D E F
+ //
+ // It should be D, E.
+
+ // Unrelated types.
+ return null;
+}
+
+/// Returns the interaction of extract spaces [left] and [right].
+Space _intersectExtracts(ExtractSpace left, ExtractSpace right) {
+ StaticType? type = intersectTypes(left.type, right.type);
+
+ // If the types are disjoint, the intersection is empty.
+ if (type == null) return Space.empty;
+
+ // Recursively intersect the fields.
+ List<String> fieldNames =
+ {...left.fields.keys, ...right.fields.keys}.toList();
+
+ // Sorting isn't needed for correctness, just to make the tests less brittle.
+ fieldNames.sort();
+
+ Map<String, Space> fields = <String, Space>{};
+ for (String name in fieldNames) {
+ Space field = _intersectFields(left.fields[name], right.fields[name]);
+
+ // If the fields are disjoint, then the entire space will have no values.
+ if (field == Space.empty) return Space.empty;
+ fields[name] = field;
+ }
+
+ return new Space(type, fields);
+}
+
+Space _intersectFields(Space? left, Space? right) {
+ if (left == null) return right!;
+ if (right == null) return left;
+ return intersect(left, right);
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect_empty.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect_empty.dart
new file mode 100644
index 0000000..2baa029
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/intersect_empty.dart
@@ -0,0 +1,60 @@
+// Copyright (c) 2022, 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.
+
+import 'space.dart';
+import 'static_type.dart';
+
+/// Calculates whether the intersection of [left] and [right] is empty.
+///
+/// This is used to tell if two field spaces on a pair of spaces being
+/// subtracted have no common values.
+bool intersectEmpty(Space left, Space right) {
+ // The intersection with an empty space is always empty.
+ if (left == Space.empty) return true;
+ if (right == Space.empty) return true;
+
+ // The intersection of a union is empty if all of the arms are.
+ if (left is UnionSpace) {
+ return left.arms.every((arm) => intersectEmpty(arm, right));
+ }
+
+ if (right is UnionSpace) {
+ return right.arms.every((arm) => intersectEmpty(left, arm));
+ }
+
+ // Otherwise, we're intersecting two [ExtractSpaces].
+ return _intersectExtracts(left as ExtractSpace, right as ExtractSpace);
+}
+
+/// Returns true if the intersection of two static types [left] and [right] is
+/// empty.
+bool intersectTypes(StaticType left, StaticType right) {
+ // If one type is a subtype, the subtype is the intersection.
+ if (left.isSubtypeOf(right)) return false;
+ if (right.isSubtypeOf(left)) return false;
+
+ // Unrelated types.
+ return true;
+}
+
+/// Returns the interaction of extract spaces [left] and [right].
+bool _intersectExtracts(ExtractSpace left, ExtractSpace right) {
+ if (intersectTypes(left.type, right.type)) return true;
+
+ // Recursively intersect the fields.
+ List<String> fieldNames =
+ {...left.fields.keys, ...right.fields.keys}.toList();
+ for (String name in fieldNames) {
+ // If the fields are disjoint, then the entire space will have no values.
+ if (_intersectFields(left.fields[name], right.fields[name])) return true;
+ }
+
+ return false;
+}
+
+bool _intersectFields(Space? left, Space? right) {
+ if (left == null) return right! == Space.empty;
+ if (right == null) return left == Space.empty;
+ return intersectEmpty(left, right);
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/profile.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/profile.dart
new file mode 100644
index 0000000..694b568
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/profile.dart
@@ -0,0 +1,47 @@
+// Copyright (c) 2022, 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.
+
+import 'dart:math';
+
+bool enabled = false;
+
+final _counts = <String, int>{};
+
+void count(String name, [String? subname]) {
+ if (!enabled) return;
+ _counts.putIfAbsent(name, () => 0);
+ _counts[name] = _counts[name]! + 1;
+
+ if (subname != null) {
+ count('$name/$subname');
+ }
+}
+
+void log() {
+ List<String> names = _counts.keys.toList();
+ names.sort();
+ int nameLength =
+ names.fold<int>(0, (length, name) => max(length, name.length));
+ int countLength = _counts.values
+ .fold<int>(0, (length, count) => max(length, count.toString().length));
+
+ for (String name in names) {
+ print('${name.padRight(nameLength)} = '
+ '${_counts[name].toString().padLeft(countLength)}');
+ }
+}
+
+void reset() {
+ _counts.clear();
+}
+
+void run(void Function() callback) {
+ reset();
+ try {
+ callback();
+ } finally {
+ log();
+ reset();
+ }
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/space.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/space.dart
new file mode 100644
index 0000000..fe14656
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/space.dart
@@ -0,0 +1,150 @@
+// Copyright (c) 2022, 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.
+
+import 'equal.dart';
+import 'static_type.dart';
+
+/// The main space for matching types and destructuring.
+///
+/// It has a type which determines the type of values it contains. The type may
+/// be [StaticType.top] to indicate that it doesn't filter by type.
+///
+/// It may also contain zero or more named fields. The space then only contains
+/// values where the field values are contained by the corresponding field
+/// spaces.
+class ExtractSpace extends Space {
+ /// The type of values the space matches.
+ final StaticType type;
+
+ /// Any field subspaces the space matches.
+ final Map<String, Space> fields;
+
+ ExtractSpace._(this.type, [this.fields = const {}]) : super._();
+
+ /// An [ExtractSpace] with no type and no fields contains all values.
+ @override
+ bool get isTop => type == StaticType.top && fields.isEmpty;
+
+ @override
+ String toString() {
+ if (isTop) return '()';
+
+ // If there are no fields, just show the type.
+ if (fields.isEmpty) return type.name;
+
+ StringBuffer buffer = new StringBuffer();
+
+ // We model a bare record pattern by treating it like an extractor on top.
+ if (type != StaticType.top) buffer.write(type.name);
+
+ buffer.write('(');
+ bool first = true;
+
+ // Positional fields have stringified number names.
+ for (int i = 0;; i++) {
+ Space? pattern = fields[i.toString()];
+ if (pattern == null) break;
+
+ if (!first) buffer.write(', ');
+ buffer.write(pattern);
+ first = false;
+ }
+
+ fields.forEach((name, pattern) {
+ // Skip positional fields.
+ if (int.tryParse(name) != null) return;
+
+ if (!first) buffer.write(', ');
+ buffer.write('$name: $pattern');
+ first = false;
+ });
+
+ buffer.write(')');
+
+ return buffer.toString();
+ }
+}
+
+// TODO(paulberry, rnystrom): List spaces.
+
+abstract class Space {
+ static final _EmptySpace empty = new _EmptySpace._();
+ static final Space top = new Space(StaticType.top);
+
+ factory Space(StaticType type, [Map<String, Space> fields = const {}]) =>
+ new ExtractSpace._(type, fields);
+
+ factory Space.record([Map<String, Space> fields = const {}]) =>
+ new Space(StaticType.top, fields);
+
+ factory Space.union(List<Space> arms) {
+ // Simplify the arms if possible.
+ List<Space> allArms = <Space>[];
+
+ void addSpace(Space space) {
+ // Discard duplicate arms. Duplicates can appear when working through a
+ // series of cases that destructure multiple fields with different types.
+ // Discarding the duplicates isn't necessary for correctness (a union with
+ // redundant arms contains the same set of values), but improves
+ // performance greatly. In the "sealed subtypes large T with all cases"
+ // test, you end up with a union containing 2520 arms, 2488 are
+ // duplicates. With this check, the largest union has only 5 arms.
+ //
+ // This is O(n^2) since we define only equality on spaces, but a real
+ // implementation would likely define hash code too and then simply
+ // create a hash set to merge duplicates in O(n) time.
+ for (Space existing in allArms) {
+ if (equal(existing, space, 'dedupe union')) return;
+ }
+
+ allArms.add(space);
+ }
+
+ for (Space space in arms) {
+ // Discard empty arms.
+ if (space == empty) continue;
+
+ // Flatten unions. We don't need to flatten recursively since we always
+ // go through this constructor to create unions. A UnionSpace will never
+ // contain UnionSpaces.
+ if (space is UnionSpace) {
+ for (Space arm in space.arms) {
+ addSpace(arm);
+ }
+ } else {
+ addSpace(space);
+ }
+ }
+
+ if (allArms.isEmpty) return empty;
+ if (allArms.length == 1) return allArms.first;
+ return new UnionSpace._(allArms);
+ }
+
+ Space._();
+
+ /// An untyped record space with no fields matches all values and thus isn't
+ /// very useful.
+ bool get isTop => false;
+}
+
+/// A union of spaces. The space A|B contains all of the values of A and B.
+class UnionSpace extends Space {
+ final List<Space> arms;
+
+ UnionSpace._(this.arms) : super._() {
+ assert(arms.length > 1);
+ }
+
+ @override
+ String toString() => arms.join('|');
+}
+
+/// The uninhabited space.
+class _EmptySpace extends Space {
+ _EmptySpace._() : super._();
+
+ @override
+ String toString() => '∅';
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/static_type.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/static_type.dart
new file mode 100644
index 0000000..647e36d
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/static_type.dart
@@ -0,0 +1,139 @@
+// Copyright (c) 2022, 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.
+
+// TODO(paulberry,rnystrom): Generics.
+
+/// A static type in the type system.
+class StaticType {
+ /// Built-in top type that all types are a subtype of.
+ static final StaticType top = new StaticType('top', inherits: []);
+
+ static final StaticType nullType = new StaticType('Null');
+
+ final String name;
+
+ late final StaticType nullable = new StaticType._nullable(this);
+
+ /// If this type is a nullable type, then this is the underlying type.
+ ///
+ /// Otherwise `null`.
+ final StaticType? _underlying;
+
+ /// Whether this type is sealed. A sealed type is implicitly abstract and has
+ /// a closed set of known subtypes. This means that every instance of the
+ /// type must be an instance of one of those subtypes. Conversely, if an
+ /// instance is *not* an instance of one of those subtypes, that it must not
+ /// be an instance of this type.
+ ///
+ /// Note that subtypes of a sealed type do not themselves have to be sealed.
+ /// Consider:
+ ///
+ /// (A)
+ /// / \
+ /// B C
+ ///
+ /// Here, A is sealed and B and C are not. There may be many unknown
+ /// subclasses of B and C, or classes implementing their interfaces. That
+ /// doesn't interfere with exhaustiveness checking because it's still the
+ /// case that any instance of A must be either a B or C *or some subtype of
+ /// one of those two types*.
+ final bool isSealed;
+
+ final Map<String, StaticType> _fields;
+
+ final List<StaticType> _supertypes = [];
+
+ final List<StaticType> _subtypes = [];
+
+ StaticType(this.name,
+ {this.isSealed = false,
+ List<StaticType>? inherits,
+ Map<String, StaticType> fields = const {}})
+ : _underlying = null,
+ _fields = fields {
+ if (inherits != null) {
+ for (StaticType type in inherits) {
+ _supertypes.add(type);
+ type._subtypes.add(this);
+ }
+ } else {
+ _supertypes.add(top);
+ }
+
+ int sealed = 0;
+ for (StaticType supertype in _supertypes) {
+ if (supertype.isSealed) sealed++;
+ }
+
+ // We don't allow a sealed type's subtypes to be shared with some other
+ // sibling supertype, as in D here:
+ //
+ // (A) (B)
+ // / \ / \
+ // C D E
+ //
+ // We could remove this restriction but doing so will require
+ // expandTypes() to be more complex. In the example here, if we subtract
+ // E from A, the result should be C|D. That requires knowing that B should
+ // be expanded, which expandTypes() doesn't currently handle.
+ if (sealed > 1) {
+ throw new ArgumentError('Can only have one sealed supertype.');
+ }
+ }
+
+ StaticType._nullable(StaticType underlying)
+ : name = '${underlying.name}?',
+ _underlying = underlying,
+ isSealed = true,
+ // No fields because it may match null which doesn't have them.
+ _fields = {} {}
+
+ /// The static types of the fields this type exposes for record destructuring.
+ ///
+ /// Includes inherited fields.
+ Map<String, StaticType> get fields {
+ return {
+ for (StaticType supertype in _supertypes) ...supertype.fields,
+ ..._fields
+ };
+ }
+
+ bool get isNullable => _underlying != null;
+
+ /// The immediate subtypes of this type.
+ Iterable<StaticType> get subtypes => _subtypes;
+
+ /// The underlying type of this nullable type. It's an error to call this on
+ /// a non-nullable type.
+ StaticType get underlying => _underlying!;
+
+ bool isSubtypeOf(StaticType other) {
+ if (this == other) return true;
+
+ // Null is a subtype of all nullable types.
+ if (this == nullType && other._underlying != null) return true;
+
+ // A nullable type is a subtype if the underlying type and Null both are.
+ StaticType? underlying = _underlying;
+ if (underlying != null) {
+ return underlying.isSubtypeOf(other) && nullType.isSubtypeOf(other);
+ }
+
+ // A non-nullable type is a subtype of the underlying type of a nullable
+ // type.
+ StaticType? otherUnderlying = other._underlying;
+ if (otherUnderlying != null) {
+ return isSubtypeOf(otherUnderlying);
+ }
+
+ for (StaticType supertype in _supertypes) {
+ if (supertype.isSubtypeOf(other)) return true;
+ }
+
+ return false;
+ }
+
+ @override
+ String toString() => name;
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/subtract.dart b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/subtract.dart
new file mode 100644
index 0000000..2da2157
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/exhaustiveness/subtract.dart
@@ -0,0 +1,182 @@
+// Copyright (c) 2022, 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.
+
+import 'intersect_empty.dart';
+import 'profile.dart' as profile;
+import 'space.dart';
+import 'static_type.dart';
+
+/// Recursively replaces [left] with a union of its sealed subtypes as long as
+/// doing so enables it to more precisely match against [right].
+List<StaticType> expandType(StaticType left, StaticType right) {
+ // If [left] is nullable and right is null or non-nullable, then expand the
+ // nullable type.
+ if (left.isNullable && (right == StaticType.nullType || !right.isNullable)) {
+ return [...expandType(left.underlying, right), StaticType.nullType];
+ }
+
+ // If [right] is nullable, then expand using its underlying type.
+ if (right.isNullable) {
+ return expandType(left, right.underlying);
+ }
+
+ // If [left] is a sealed supertype and [right] is in its subtype hierarchy,
+ // then expand out the subtypes (recursively) to more precisely match [right].
+ if (left.isSealed && left != right && right.isSubtypeOf(left)) {
+ return {
+ for (StaticType subtype in left.subtypes) ...expandType(subtype, right),
+ }.toList();
+ }
+
+ return [left];
+}
+
+/// Returns a new [Space] that contains all of the values of [left] that are
+/// not also in [right].
+Space subtract(Space left, Space right) {
+ profile.count('subtract');
+
+ // Subtracting from empty is still empty.
+ if (left == Space.empty) return Space.empty;
+
+ // Subtracting nothing leaves it unchanged.
+ if (right == Space.empty) return left;
+
+ // Distribute a union on the left.
+ // A|B - x => A-x | B-x
+ if (left is UnionSpace) {
+ return new Space.union(
+ left.arms.map((arm) => subtract(arm, right)).toList());
+ }
+
+ // Distribute a union on the right.
+ // x - A|B => x - A - B
+ if (right is UnionSpace) {
+ Space result = left;
+ for (Space arm in right.arms) {
+ result = subtract(result, arm);
+ }
+ return result;
+ }
+
+ // Otherwise, it must be two extract spaces.
+ return _subtractExtract(left as ExtractSpace, right as ExtractSpace);
+}
+
+/// Returns `true` if every field in [leftFields] is covered by the
+/// corresponding field in [rightFields].
+bool _isLeftSubspace(StaticType leftType, List<String> fieldNames,
+ Map<String, Space> leftFields, Map<String, Space> rightFields) {
+ for (String name in fieldNames) {
+ if (subtract(leftFields[name]!, rightFields[name]!) != Space.empty) {
+ return false;
+ }
+ }
+
+ // If we get here, every field covered.
+ return true;
+}
+
+/// Subtract [right] from [left].
+Space _subtractExtract(ExtractSpace left, ExtractSpace right) {
+ List<String> fieldNames =
+ {...left.fields.keys, ...right.fields.keys}.toList();
+
+ List<Space> spaces = <Space>[];
+
+ // If the left type is in a sealed hierarchy, expanding it to its subtypes
+ // might let us calculate the subtraction more precisely.
+ List<StaticType> subtypes = expandType(left.type, right.type);
+ for (StaticType subtype in subtypes) {
+ spaces.addAll(_subtractExtractAtType(subtype, left, right, fieldNames));
+ }
+
+ return new Space.union(spaces);
+}
+
+/// Subtract [right] from [left], but using [type] for left's type, which may
+/// be a more specific subtype of [left]'s own type is a sealed supertype.
+List<Space> _subtractExtractAtType(StaticType type, ExtractSpace left,
+ ExtractSpace right, List<String> fieldNames) {
+ // If the right type doesn't cover the left (even after expanding sealed
+ // types), then we can't do anything with the fields since they may not
+ // even come into play for all values. Subtract nothing from this subtype
+ // and keep all of the current fields.
+ if (!type.isSubtypeOf(right.type)) return [new Space(type, left.fields)];
+
+ // Infer any fields that appear in one space and not the other.
+ Map<String, Space> leftFields = <String, Space>{};
+ Map<String, Space> rightFields = <String, Space>{};
+ for (String name in fieldNames) {
+ // If the right space matches on a field that the left doesn't have, infer
+ // it from the static type of the field. That contains the same set of
+ // values as having no field at all.
+ leftFields[name] = left.fields[name] ?? new Space(type.fields[name]!);
+
+ // If the left matches on a field that the right doesn't have, infer top
+ // for the right field since the right will accept any of left's values for
+ // that field.
+ rightFields[name] = right.fields[name] ?? Space.top;
+ }
+
+ // If any pair of fields have no overlapping values, then no overall value
+ // that matches the left space will also match the right space. So the right
+ // space doesn't subtract anything and we keep the left space as-is.
+ for (String name in fieldNames) {
+ if (intersectEmpty(leftFields[name]!, rightFields[name]!)) {
+ return [new Space(type, left.fields)];
+ }
+ }
+
+ // If all the right's fields strictly cover all of the left's, then the
+ // right completely subtracts this type and nothing remains.
+ if (_isLeftSubspace(type, fieldNames, leftFields, rightFields)) {
+ return const [];
+ }
+
+ // The right side is a supertype but its fields don't totally cover, so
+ // handle each of them individually.
+
+ // Walk the fields and see which ones are modified by the right-hand fields.
+ Map<String, Space> fixed = <String, Space>{};
+ Map<String, Space> changedDifference = <String, Space>{};
+ for (String name in fieldNames) {
+ Space difference = subtract(leftFields[name]!, rightFields[name]!);
+ if (difference == Space.empty) {
+ // The right field accepts all the values that the left field accepts, so
+ // keep the left field as it is.
+ fixed[name] = leftFields[name]!;
+ } else if (difference.isTop) {
+ // If the resulting field matches everything, simply discard it since
+ // it's equivalent to omitting the field.
+ } else {
+ changedDifference[name] = difference;
+ }
+ }
+
+ // If no fields are affected by the subtraction, just return a single arm
+ // with all of the fields.
+ if (changedDifference.isEmpty) return [new Space(type, fixed)];
+
+ // For each field whose `left - right` is different, include an arm that
+ // includes that one difference.
+ List<String> changedFields = changedDifference.keys.toList();
+ List<Space> spaces = <Space>[];
+ for (int i = 0; i < changedFields.length; i++) {
+ Map<String, Space> fields = {...fixed};
+
+ for (int j = 0; j < changedFields.length; j++) {
+ String name = changedFields[j];
+ if (i == j) {
+ fields[name] = changedDifference[name]!;
+ } else {
+ fields[name] = leftFields[name]!;
+ }
+ }
+
+ spaces.add(new Space(type, fields));
+ }
+
+ return spaces;
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/expand_type_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/expand_type_test.dart
new file mode 100644
index 0000000..0b0adb7
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/expand_type_test.dart
@@ -0,0 +1,232 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/subtract.dart';
+import 'package:test/test.dart';
+
+void main() {
+ test('sealed', () {
+ // (A)
+ // /|\
+ // B C(D)
+ // / \
+ // E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', isSealed: true, inherits: [a]);
+ var e = StaticType('E', inherits: [d]);
+ var f = StaticType('F', inherits: [d]);
+
+ expectExpand(a, a, 'A');
+ expectExpand(a, b, 'B|C|D');
+ expectExpand(a, c, 'B|C|D');
+ expectExpand(a, d, 'B|C|D');
+ expectExpand(a, e, 'B|C|E|F');
+ expectExpand(a, f, 'B|C|E|F');
+
+ expectExpand(d, a, 'D');
+ expectExpand(d, b, 'D');
+ expectExpand(d, c, 'D');
+ expectExpand(d, d, 'D');
+ expectExpand(d, e, 'E|F');
+ expectExpand(d, f, 'E|F');
+ });
+
+ test('unsealed', () {
+ // A
+ // /|\
+ // B C D
+ // / \
+ // E F
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var e = StaticType('E', inherits: [d]);
+ var f = StaticType('F', inherits: [d]);
+
+ expectExpand(a, a, 'A');
+ expectExpand(a, b, 'A');
+ expectExpand(a, c, 'A');
+ expectExpand(a, d, 'A');
+ expectExpand(a, e, 'A');
+ expectExpand(a, f, 'A');
+
+ expectExpand(d, a, 'D');
+ expectExpand(d, b, 'D');
+ expectExpand(d, c, 'D');
+ expectExpand(d, d, 'D');
+ expectExpand(d, e, 'D');
+ expectExpand(d, f, 'D');
+ });
+
+ test('unsealed in middle', () {
+ // (A)
+ // / \
+ // B C
+ // / \
+ // D (E)
+ // / \
+ // F G
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [c]);
+ var e = StaticType('E', isSealed: true, inherits: [c]);
+ var f = StaticType('F', inherits: [e]);
+ var g = StaticType('G', inherits: [e]);
+
+ expectExpand(a, a, 'A');
+ expectExpand(a, b, 'B|C');
+ expectExpand(a, c, 'B|C');
+ expectExpand(a, d, 'B|C');
+ expectExpand(a, e, 'B|C');
+ expectExpand(a, f, 'B|C');
+
+ expectExpand(c, a, 'C');
+ expectExpand(c, b, 'C');
+ expectExpand(c, c, 'C');
+ expectExpand(c, d, 'C');
+ expectExpand(c, e, 'C');
+ expectExpand(c, f, 'C');
+
+ expectExpand(e, a, 'E');
+ expectExpand(e, b, 'E');
+ expectExpand(e, c, 'E');
+ expectExpand(e, e, 'E');
+ expectExpand(e, f, 'F|G');
+ expectExpand(e, g, 'F|G');
+ });
+
+ test('transitive sealed family', () {
+ // (A)
+ // / \
+ // (B) (C)
+ // / | | \
+ // D E F G
+ // \ /
+ // H
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', isSealed: true, inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b]);
+ var f = StaticType('F', inherits: [c]);
+ var g = StaticType('G', inherits: [c]);
+ var h = StaticType('H', inherits: [e, f]);
+
+ expectExpand(a, a, 'A');
+ expectExpand(a, b, 'B|C');
+ expectExpand(a, c, 'B|C');
+ expectExpand(a, d, 'D|E|C');
+ expectExpand(a, e, 'D|E|C');
+ expectExpand(a, f, 'B|F|G');
+ expectExpand(a, g, 'B|F|G');
+ expectExpand(a, h, 'D|E|F|G');
+
+ expectExpand(b, a, 'B');
+ expectExpand(b, b, 'B');
+ expectExpand(b, c, 'B');
+ expectExpand(b, d, 'D|E');
+ expectExpand(b, e, 'D|E');
+ expectExpand(b, f, 'B');
+ expectExpand(b, h, 'D|E');
+
+ expectExpand(d, a, 'D');
+ expectExpand(d, b, 'D');
+ expectExpand(d, c, 'D');
+ expectExpand(d, d, 'D');
+ expectExpand(d, e, 'D');
+ expectExpand(d, f, 'D');
+
+ expectExpand(e, a, 'E');
+ expectExpand(e, b, 'E');
+ expectExpand(e, c, 'E');
+ expectExpand(e, d, 'E');
+ expectExpand(e, e, 'E');
+ expectExpand(e, f, 'E');
+ expectExpand(e, h, 'E');
+
+ expectExpand(h, a, 'H');
+ expectExpand(h, b, 'H');
+ expectExpand(h, d, 'H');
+ expectExpand(h, e, 'H');
+ expectExpand(h, h, 'H');
+ });
+
+ test('sealed with multiple paths', () {
+ // (A)
+ // / \
+ // (B) C
+ // / \ /
+ // D E
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b, c]);
+
+ expectExpand(a, a, 'A');
+ expectExpand(a, b, 'B|C');
+ expectExpand(a, c, 'B|C');
+ expectExpand(a, d, 'D|E|C');
+ expectExpand(a, e, 'D|E|C');
+
+ expectExpand(b, a, 'B');
+ expectExpand(b, b, 'B');
+ expectExpand(b, c, 'B');
+ expectExpand(b, d, 'D|E');
+ expectExpand(b, e, 'D|E');
+
+ expectExpand(c, a, 'C');
+ expectExpand(c, b, 'C');
+ expectExpand(c, c, 'C');
+ expectExpand(c, d, 'C');
+ expectExpand(c, e, 'C');
+
+ expectExpand(d, a, 'D');
+ expectExpand(d, b, 'D');
+ expectExpand(d, c, 'D');
+ expectExpand(d, d, 'D');
+ expectExpand(d, e, 'D');
+
+ expectExpand(e, a, 'E');
+ expectExpand(e, b, 'E');
+ expectExpand(e, c, 'E');
+ expectExpand(e, d, 'E');
+ expectExpand(e, e, 'E');
+ });
+
+ test('nullable', () {
+ // (A)
+ // / \
+ // B C
+ // / \
+ // D E
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [c]);
+
+ expectExpand(a.nullable, a, 'A|Null');
+ expectExpand(a, a.nullable, 'A');
+ expectExpand(a.nullable, a.nullable, 'A|Null');
+
+ // Sealed subtype.
+ expectExpand(a.nullable, b, 'B|C|Null');
+ expectExpand(a, b.nullable, 'B|C');
+ expectExpand(a.nullable, b.nullable, 'B|C|Null');
+
+ // Unsealed subtype.
+ expectExpand(c.nullable, d, 'C|Null');
+ expectExpand(c, d.nullable, 'C');
+ expectExpand(c.nullable, d.nullable, 'C|Null');
+ });
+}
+
+void expectExpand(StaticType left, StaticType right, String expected) {
+ expect(expandType(left, right).join('|'), expected);
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_empty_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_empty_test.dart
new file mode 100644
index 0000000..d25df88
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_empty_test.dart
@@ -0,0 +1,77 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/intersect_empty.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+
+ Space A({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ a, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+ Space B({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ b, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+ Space C({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ c, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+
+ test('records', () {
+ expectIntersectEmpty(rec(x: a, y: a), rec(x: a, y: a), isFalse);
+ expectIntersectEmpty(rec(x: a, y: a), rec(x: a), isFalse);
+ expectIntersectEmpty(rec(w: a, x: a), rec(y: a, z: a), isFalse);
+ expectIntersectEmpty(rec(w: a, x: a, y: a), rec(x: a, y: a, z: a), isFalse);
+ });
+
+ test('types', () {
+ // Note: More comprehensive tests under intersect_types_test.dart.
+ expectIntersectEmpty(a, a, isFalse);
+ expectIntersectEmpty(a, b, isFalse);
+ expectIntersectEmpty(a, c, isFalse);
+ expectIntersectEmpty(b, c, isTrue);
+ });
+
+ test('field types', () {
+ expectIntersectEmpty(rec(x: a, y: b), rec(x: b, y: a), isFalse);
+ expectIntersectEmpty(rec(x: b), rec(x: c), isTrue);
+ });
+
+ test('types and fields', () {
+ expectIntersectEmpty(A(x: a), A(x: a), isFalse);
+ expectIntersectEmpty(A(x: a), A(x: b), isFalse);
+ expectIntersectEmpty(A(x: b), A(x: c), isTrue);
+
+ expectIntersectEmpty(A(x: a), B(x: a), isFalse);
+ expectIntersectEmpty(A(x: a), B(x: b), isFalse);
+ expectIntersectEmpty(A(x: b), B(x: c), isTrue);
+
+ expectIntersectEmpty(B(x: a), A(x: a), isFalse);
+ expectIntersectEmpty(B(x: a), A(x: b), isFalse);
+ expectIntersectEmpty(B(x: b), A(x: c), isTrue);
+
+ expectIntersectEmpty(B(x: a), B(x: a), isFalse);
+ expectIntersectEmpty(B(x: a), B(x: b), isFalse);
+ expectIntersectEmpty(B(x: b), B(x: c), isTrue);
+
+ expectIntersectEmpty(B(x: a), C(x: a), isTrue);
+ expectIntersectEmpty(B(x: a), C(x: b), isTrue);
+ expectIntersectEmpty(B(x: b), C(x: c), isTrue);
+ });
+}
+
+void expectIntersectEmpty(Object left, Object right, Matcher expected) {
+ var leftSpace = parseSpace(left);
+ var rightSpace = parseSpace(right);
+
+ // Intersection is symmetric so try both directions.
+ expect(intersectEmpty(leftSpace, rightSpace), expected);
+ expect(intersectEmpty(rightSpace, leftSpace), expected);
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_test.dart
new file mode 100644
index 0000000..f90fa5a
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_test.dart
@@ -0,0 +1,80 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/intersect.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+
+ Space A({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ a, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+ Space B({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ b, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+ Space C({StaticType? x, StaticType? y, StaticType? z}) => ty(
+ c, {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+
+ test('records', () {
+ expectIntersect(rec(x: a, y: a), rec(x: a, y: a), rec(x: a, y: a));
+ expectIntersect(rec(x: a, y: a), rec(x: a), rec(x: a, y: a));
+ expectIntersect(
+ rec(w: a, x: a), rec(y: a, z: a), rec(w: a, x: a, y: a, z: a));
+ expectIntersect(rec(w: a, x: a, y: a), rec(x: a, y: a, z: a),
+ rec(w: a, x: a, y: a, z: a));
+ });
+
+ test('types', () {
+ // Note: More comprehensive tests under intersect_types_test.dart.
+ expectIntersect(a, a, a);
+ expectIntersect(a, b, b);
+ expectIntersect(a, c, c);
+ expectIntersect(b, c, '∅');
+ });
+
+ test('field types', () {
+ expectIntersect(rec(x: a, y: b), rec(x: b, y: a), rec(x: b, y: b));
+ expectIntersect(rec(x: b), rec(x: c), '∅');
+ });
+
+ test('types and fields', () {
+ expectIntersect(A(x: a), A(x: a), A(x: a));
+ expectIntersect(A(x: a), A(x: b), A(x: b));
+ expectIntersect(A(x: b), A(x: c), '∅');
+
+ expectIntersect(A(x: a), B(x: a), B(x: a));
+ expectIntersect(A(x: a), B(x: b), B(x: b));
+ expectIntersect(A(x: b), B(x: c), '∅');
+
+ expectIntersect(B(x: a), A(x: a), B(x: a));
+ expectIntersect(B(x: a), A(x: b), B(x: b));
+ expectIntersect(B(x: b), A(x: c), '∅');
+
+ expectIntersect(B(x: a), B(x: a), B(x: a));
+ expectIntersect(B(x: a), B(x: b), B(x: b));
+ expectIntersect(B(x: b), B(x: c), '∅');
+
+ expectIntersect(B(x: a), C(x: a), '∅');
+ expectIntersect(B(x: a), C(x: b), '∅');
+ expectIntersect(B(x: b), C(x: c), '∅');
+ });
+}
+
+void expectIntersect(Object left, Object right, Object expected) {
+ var leftSpace = parseSpace(left);
+ var rightSpace = parseSpace(right);
+ var expectedText = parseSpace(expected).toString();
+
+ // Intersection is symmetric so try both directions.
+ expect(intersect(leftSpace, rightSpace).toString(), expectedText);
+ expect(intersect(rightSpace, leftSpace).toString(), expectedText);
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_types_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_types_test.dart
new file mode 100644
index 0000000..704e9fd
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/intersect_types_test.dart
@@ -0,0 +1,99 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/intersect.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+void main() {
+ test('hierarchy', () {
+ // (A)
+ // /|\
+ // B C(D)
+ // / \
+ // E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', isSealed: true, inherits: [a]);
+ var e = StaticType('E', inherits: [d]);
+ var f = StaticType('F', inherits: [d]);
+
+ expectIntersect(a, a, a);
+ expectIntersect(a, b, b);
+ expectIntersect(a, c, c);
+ expectIntersect(a, d, d);
+ expectIntersect(a, e, e);
+ expectIntersect(a, f, f);
+
+ expectIntersect(b, b, b);
+ expectIntersect(b, c, null);
+ expectIntersect(b, d, null);
+ expectIntersect(b, e, null);
+ expectIntersect(b, f, null);
+
+ expectIntersect(c, c, c);
+ expectIntersect(c, d, null);
+ expectIntersect(c, e, null);
+ expectIntersect(c, f, null);
+
+ expectIntersect(d, d, d);
+ expectIntersect(d, e, e);
+ expectIntersect(d, f, f);
+
+ expectIntersect(e, e, e);
+ expectIntersect(e, f, null);
+ });
+
+ test('sealed with multiple paths', () {
+ // (A)
+ // / \
+ // (B) C
+ // / \ /
+ // D E
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b, c]);
+
+ expectIntersect(a, a, a);
+ expectIntersect(a, b, b);
+ expectIntersect(a, c, c);
+ expectIntersect(a, d, d);
+ expectIntersect(a, e, e);
+ expectIntersect(b, b, b);
+ expectIntersect(b, c, null);
+ expectIntersect(b, d, d);
+ expectIntersect(b, e, e);
+ expectIntersect(c, c, c);
+ expectIntersect(c, d, null);
+ expectIntersect(c, e, e);
+ expectIntersect(d, d, d);
+ expectIntersect(d, e, null);
+ expectIntersect(e, e, e);
+ });
+
+ test('nullable', () {
+ // A
+ // |
+ // B
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+
+ expectIntersect(a, a.nullable, a);
+ expectIntersect(a, StaticType.nullType, null);
+ expectIntersect(a.nullable, StaticType.nullType, StaticType.nullType);
+
+ expectIntersect(a, b.nullable, b);
+ expectIntersect(a.nullable, b, b);
+ expectIntersect(a.nullable, b.nullable, b.nullable);
+ });
+}
+
+void expectIntersect(StaticType left, StaticType right, StaticType? expected) {
+ // Intersection is symmetric so try both directions.
+ expect(intersectTypes(left, right), expected);
+ expect(intersectTypes(right, left), expected);
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_field_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_field_test.dart
new file mode 100644
index 0000000..e127979
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_field_test.dart
@@ -0,0 +1,259 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ group('sealed subtypes', () {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var t = StaticType('T', fields: {'x': a, 'y': a});
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b, 'y': b},
+ {'x': b, 'y': c},
+ {'x': c, 'y': b},
+ {'x': c, 'y': c},
+ ]);
+ });
+
+ group('sealed subtypes medium', () {
+ // (A)
+ // /|\
+ // B C D
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var t = StaticType('T', fields: {'y': a, 'z': a});
+
+ expectExhaustiveOnlyAll(t, [
+ {'y': b, 'z': b},
+ {'y': b, 'z': c},
+ {'y': b, 'z': d},
+ {'y': c, 'z': b},
+ {'y': c, 'z': c},
+ {'y': c, 'z': d},
+ {'y': d, 'z': b},
+ {'y': d, 'z': c},
+ {'y': d, 'z': d},
+ ]);
+ });
+
+ group('sealed subtypes large', () {
+ // (A)
+ // /|\
+ // B C D
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var t = StaticType('T', fields: {'w': a, 'x': a, 'y': a, 'z': a});
+
+ expectExhaustiveOnlyAll(t, [
+ {'w': b, 'x': b, 'y': b, 'z': b},
+ {'w': b, 'x': b, 'y': b, 'z': c},
+ {'w': b, 'x': b, 'y': b, 'z': d},
+ {'w': b, 'x': b, 'y': c, 'z': b},
+ {'w': b, 'x': b, 'y': c, 'z': c},
+ {'w': b, 'x': b, 'y': c, 'z': d},
+ {'w': b, 'x': b, 'y': d, 'z': b},
+ {'w': b, 'x': b, 'y': d, 'z': c},
+ {'w': b, 'x': b, 'y': d, 'z': d},
+ {'w': b, 'x': c, 'y': b, 'z': b},
+ {'w': b, 'x': c, 'y': b, 'z': c},
+ {'w': b, 'x': c, 'y': b, 'z': d},
+ {'w': b, 'x': c, 'y': c, 'z': b},
+ {'w': b, 'x': c, 'y': c, 'z': c},
+ {'w': b, 'x': c, 'y': c, 'z': d},
+ {'w': b, 'x': c, 'y': d, 'z': b},
+ {'w': b, 'x': c, 'y': d, 'z': c},
+ {'w': b, 'x': c, 'y': d, 'z': d},
+ {'w': b, 'x': d, 'y': b, 'z': b},
+ {'w': b, 'x': d, 'y': b, 'z': c},
+ {'w': b, 'x': d, 'y': b, 'z': d},
+ {'w': b, 'x': d, 'y': c, 'z': b},
+ {'w': b, 'x': d, 'y': c, 'z': c},
+ {'w': b, 'x': d, 'y': c, 'z': d},
+ {'w': b, 'x': d, 'y': d, 'z': b},
+ {'w': b, 'x': d, 'y': d, 'z': c},
+ {'w': b, 'x': d, 'y': d, 'z': d},
+ {'w': c, 'x': b, 'y': b, 'z': b},
+ {'w': c, 'x': b, 'y': b, 'z': c},
+ {'w': c, 'x': b, 'y': b, 'z': d},
+ {'w': c, 'x': b, 'y': c, 'z': b},
+ {'w': c, 'x': b, 'y': c, 'z': c},
+ {'w': c, 'x': b, 'y': c, 'z': d},
+ {'w': c, 'x': b, 'y': d, 'z': b},
+ {'w': c, 'x': b, 'y': d, 'z': c},
+ {'w': c, 'x': b, 'y': d, 'z': d},
+ {'w': c, 'x': c, 'y': b, 'z': b},
+ {'w': c, 'x': c, 'y': b, 'z': c},
+ {'w': c, 'x': c, 'y': b, 'z': d},
+ {'w': c, 'x': c, 'y': c, 'z': b},
+ {'w': c, 'x': c, 'y': c, 'z': c},
+ {'w': c, 'x': c, 'y': c, 'z': d},
+ {'w': c, 'x': c, 'y': d, 'z': b},
+ {'w': c, 'x': c, 'y': d, 'z': c},
+ {'w': c, 'x': c, 'y': d, 'z': d},
+ {'w': c, 'x': d, 'y': b, 'z': b},
+ {'w': c, 'x': d, 'y': b, 'z': c},
+ {'w': c, 'x': d, 'y': b, 'z': d},
+ {'w': c, 'x': d, 'y': c, 'z': b},
+ {'w': c, 'x': d, 'y': c, 'z': c},
+ {'w': c, 'x': d, 'y': c, 'z': d},
+ {'w': c, 'x': d, 'y': d, 'z': b},
+ {'w': c, 'x': d, 'y': d, 'z': c},
+ {'w': c, 'x': d, 'y': d, 'z': d},
+ {'w': d, 'x': b, 'y': b, 'z': b},
+ {'w': d, 'x': b, 'y': b, 'z': c},
+ {'w': d, 'x': b, 'y': b, 'z': d},
+ {'w': d, 'x': b, 'y': c, 'z': b},
+ {'w': d, 'x': b, 'y': c, 'z': c},
+ {'w': d, 'x': b, 'y': c, 'z': d},
+ {'w': d, 'x': b, 'y': d, 'z': b},
+ {'w': d, 'x': b, 'y': d, 'z': c},
+ {'w': d, 'x': b, 'y': d, 'z': d},
+ {'w': d, 'x': c, 'y': b, 'z': b},
+ {'w': d, 'x': c, 'y': b, 'z': c},
+ {'w': d, 'x': c, 'y': b, 'z': d},
+ {'w': d, 'x': c, 'y': c, 'z': b},
+ {'w': d, 'x': c, 'y': c, 'z': c},
+ {'w': d, 'x': c, 'y': c, 'z': d},
+ {'w': d, 'x': c, 'y': d, 'z': b},
+ {'w': d, 'x': c, 'y': d, 'z': c},
+ {'w': d, 'x': c, 'y': d, 'z': d},
+ {'w': d, 'x': d, 'y': b, 'z': b},
+ {'w': d, 'x': d, 'y': b, 'z': c},
+ {'w': d, 'x': d, 'y': b, 'z': d},
+ {'w': d, 'x': d, 'y': c, 'z': b},
+ {'w': d, 'x': d, 'y': c, 'z': c},
+ {'w': d, 'x': d, 'y': c, 'z': d},
+ {'w': d, 'x': d, 'y': d, 'z': b},
+ {'w': d, 'x': d, 'y': d, 'z': c},
+ {'w': d, 'x': d, 'y': d, 'z': d},
+ ]);
+ });
+
+ group('sealed transitive subtypes', () {
+ // (A)
+ // / \
+ // (B) (C)
+ // / \ \
+ // D E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', isSealed: true, inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b]);
+ var f = StaticType('F', inherits: [c]);
+
+ var t = StaticType('T', fields: {'x': a, 'y': a});
+ expectExhaustiveOnlyAll(t, [
+ {'x': a, 'y': a},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b, 'y': b},
+ {'x': b, 'y': c},
+ {'x': c, 'y': b},
+ {'x': c, 'y': c},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b, 'y': d},
+ {'x': b, 'y': e},
+ {'x': b, 'y': f},
+ {'x': c, 'y': d},
+ {'x': c, 'y': e},
+ {'x': c, 'y': f},
+ ]);
+ });
+
+ group('unsealed subtypes', () {
+ // A
+ // / \
+ // B C
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+
+ // Not exhaustive even when known subtypes covered.
+ var t = StaticType('T', fields: {'x': a, 'y': a});
+ expectNeverExhaustive(t, [
+ {'x': b, 'y': b},
+ {'x': b, 'y': c},
+ {'x': c, 'y': b},
+ {'x': c, 'y': c},
+ ]);
+
+ // Exhaustive if field static type is a covered subtype.
+ var u = StaticType('T', fields: {'x': b, 'y': c});
+ expectExhaustiveOnlyAll(u, [
+ {'x': b, 'y': c},
+ ]);
+ });
+
+ group('different fields', () {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var t = StaticType('T', fields: {'x': a, 'y': a, 'z': a});
+
+ expectNeverExhaustive(t, [
+ {'x': b},
+ {'y': b},
+ {'z': b},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b, 'y': a},
+ {'x': c, 'z': a},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b, 'y': b},
+ {'x': b, 'y': c},
+ {'x': c, 'y': b},
+ {'x': c, 'y': c},
+ ]);
+ });
+
+ group('field types', () {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var t = StaticType('T', fields: {'x': a, 'y': b, 'z': c});
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': a, 'y': b, 'z': c},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'x': b},
+ {'x': c},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'y': b},
+ ]);
+
+ expectExhaustiveOnlyAll(t, [
+ {'z': c},
+ ]);
+ });
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_nested_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_nested_test.dart
new file mode 100644
index 0000000..d236651
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_nested_test.dart
@@ -0,0 +1,57 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ group('nested records', () {
+ // (A)
+ // / \
+ // B C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var t = StaticType('T', fields: {'x': a, 'y': b});
+ var u = StaticType('U', fields: {'w': t, 'z': t});
+
+ expectExhaustiveOnlyAll(u, [
+ rec(w: rec(x: a), z: t),
+ ]);
+
+ expectExhaustiveOnlyAll(u, [
+ rec(w: rec(x: a, y: a), z: rec(x: a, y: a)),
+ ]);
+
+ expectExhaustiveOnlyAll(u, [
+ rec(w: rec(x: a, y: b), z: rec(x: a, y: b)),
+ ]);
+
+ expectExhaustiveOnlyAll(u, [
+ rec(w: rec(x: b), z: t),
+ rec(w: rec(x: c), z: t),
+ ]);
+
+ expectExhaustiveOnlyAll(u, [
+ rec(w: rec(x: b, y: b), z: rec(x: b, y: b)),
+ rec(w: rec(x: b, y: b), z: rec(x: c, y: b)),
+ rec(w: rec(x: c, y: b), z: rec(x: b, y: b)),
+ rec(w: rec(x: c, y: b), z: rec(x: c, y: b)),
+ ]);
+ });
+
+ group('nested with different fields of same name', () {
+ // A B C D
+ var a = StaticType('A');
+ var b = StaticType('B', fields: {'x': a});
+ var c = StaticType('C', fields: {'x': b});
+ var d = StaticType('D', fields: {'x': c});
+
+ expectExhaustiveOnlyAll(d, [
+ rec(x: rec(x: rec(x: a))),
+ ]);
+ });
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_type_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_type_test.dart
new file mode 100644
index 0000000..77c37ed
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/is_exhaustive_type_test.dart
@@ -0,0 +1,195 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+/// Test `subtract()` on combinations of types.
+void main() {
+ // Note: In the class diagrams, "(_)" means "sealed". A bare name is unsealed.
+ group('sealed family', () {
+ // (A)
+ // / \
+ // (B) (C)
+ // / \ \
+ // D E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', isSealed: true, inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b]);
+ var f = StaticType('F', inherits: [c]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c, d, e, f]);
+ checkExhaustive([a], 'ABCDEF');
+ checkExhaustive([b], 'BDE');
+ checkExhaustive([c], 'CF');
+ checkExhaustive([d], 'D');
+ checkExhaustive([f], 'CF');
+
+ checkExhaustive([a, b], 'ABCDEF');
+ checkExhaustive([a, c], 'ABCDEF');
+ checkExhaustive([a, d], 'ABCDEF');
+ checkExhaustive([a, f], 'ABCDEF');
+
+ checkExhaustive([b, c], 'ABCDEF');
+ checkExhaustive([b, d], 'BDE');
+ checkExhaustive([b, f], 'ABCDEF');
+
+ checkExhaustive([c, d], 'CDF');
+ checkExhaustive([c, e], 'CEF');
+ checkExhaustive([c, f], 'CF');
+
+ checkExhaustive([d, e], 'BDE'); // Covers B because both cases covered.
+ checkExhaustive([d, f], 'CDF');
+ checkExhaustive([e, f], 'CEF');
+
+ checkExhaustive([d, e, f], 'ABCDEF'); // All cases covered.
+ });
+
+ group('sealed with many subtypes', () {
+ // (A)
+ // //|\\
+ // / /|\ \
+ // B C D E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a]);
+ var e = StaticType('E', inherits: [a]);
+ var f = StaticType('F', inherits: [a]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c, d, e, f]);
+ checkExhaustive([a], 'ABCDEF');
+ checkExhaustive([b], 'B');
+ checkExhaustive([c, e], 'CE');
+ checkExhaustive([b, d, f], 'BDF');
+ checkExhaustive([b, c, e, f], 'BCEF');
+ checkExhaustive([b, c, d, e, f], 'ABCDEF'); // Covers A.
+ });
+
+ group('sealed with multiple paths', () {
+ // (A)
+ // / \
+ // (B) C
+ // / \ /
+ // D E
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b, c]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c, d, e]);
+ checkExhaustive([a], 'ABCDE');
+ checkExhaustive([b], 'BDE');
+ checkExhaustive([c], 'CE');
+ checkExhaustive([d], 'D');
+ checkExhaustive([e], 'E');
+
+ checkExhaustive([b, c], 'ABCDE');
+ checkExhaustive([b, d], 'BDE');
+ checkExhaustive([b, e], 'BDE');
+ checkExhaustive([c, d], 'CDE');
+ checkExhaustive([d, e], 'BDE');
+ });
+
+ group('sealed with unsealed supertype', () {
+ // A
+ // |
+ // (B)
+ // / \
+ // C D
+ var a = StaticType('A');
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', inherits: [b]);
+ var d = StaticType('D', inherits: [b]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c, d]);
+ checkExhaustive([a], 'ABCD');
+ checkExhaustive([b], 'BCD');
+ checkExhaustive([c], 'C');
+ checkExhaustive([d], 'D');
+ checkExhaustive([c, d], 'BCD');
+ });
+
+ group('sealed with single subclass', () {
+ // (A)
+ // |
+ // (B)
+ // |
+ // C
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', inherits: [b]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c]);
+ checkExhaustive([a], 'ABC');
+ checkExhaustive([b], 'ABC'); // Every A must be a B, so A is covered.
+ checkExhaustive([c], 'ABC'); // Every C must be a B, which must be an A.
+ checkExhaustive([a, b], 'ABC');
+ checkExhaustive([a, c], 'ABC');
+ checkExhaustive([b, c], 'ABC');
+ checkExhaustive([a, b, c], 'ABC');
+ });
+
+ group('unsealed', () {
+ // A
+ // / \
+ // B C
+ // / \ / \
+ // D E F
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b, c]);
+ var f = StaticType('F', inherits: [c]);
+
+ var checkExhaustive = _makeTestFunction([a, b, c, d, e, f]);
+ checkExhaustive([a], 'ABCDEF');
+ checkExhaustive([b], 'BDE');
+ checkExhaustive([d], 'D');
+ checkExhaustive([a, b], 'ABCDEF'); // Same as A.
+ checkExhaustive([a, d], 'ABCDEF'); // Same as A.
+ checkExhaustive([d, e], 'DE'); // Doesn't cover B because unsealed.
+ checkExhaustive([d, f], 'DF');
+ checkExhaustive([e, f], 'EF'); // Doesn't cover C because unsealed.
+ checkExhaustive([b, f], 'BDEF');
+ checkExhaustive([c, d], 'CDEF');
+ checkExhaustive([d, e, f], 'DEF');
+ });
+}
+
+/// Returns a function that takes a list of `types` and a string containing a
+/// list of type letters that map to the types in [allTypes].
+///
+/// The function checks that the list of types exhaustively covers every type
+/// whose name appears in the string. So:
+///
+/// checkExhaustive([d, e], 'bde');
+///
+/// Means that the union of D|E should be exhaustive over B, D, and E and not
+/// exhaustive over the other types in [allTypes].
+Function(List<StaticType>, String) _makeTestFunction(
+ List<StaticType> allTypes) {
+ assert(allTypes.length <= 6, 'Only supports up to six types.');
+ var letters = 'ABCDEF';
+
+ return (types, covered) {
+ var spaces = types.map((type) => Space(type)).toList();
+
+ for (var i = 0; i < allTypes.length; i++) {
+ var value = Space(allTypes[i]);
+ if (covered.contains(letters[i])) {
+ expectExhaustive(value, spaces);
+ } else {
+ expectNotExhaustive(value, spaces);
+ }
+ }
+ };
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/report_errors_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/report_errors_test.dart
new file mode 100644
index 0000000..62da513
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/report_errors_test.dart
@@ -0,0 +1,129 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/exhaustive.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ // Here, "(_)" means "sealed". A bare name is unsealed.
+ //
+ // (A)
+ // / \
+ // (B) (C)
+ // / \ \
+ // D E F
+ // / \
+ // G H
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', isSealed: true, inherits: [a]);
+ var c = StaticType('C', isSealed: true, inherits: [a]);
+ var d = StaticType('D', inherits: [b]);
+ var e = StaticType('E', inherits: [b]);
+ var f = StaticType('F', inherits: [c]);
+ var g = StaticType('G', inherits: [f]);
+ var h = StaticType('H', inherits: [f]);
+
+ test('exhaustiveness', () {
+ // Case matching top type covers all subtypes.
+ expectReportErrors(a, [a]);
+ expectReportErrors(b, [a]);
+ expectReportErrors(d, [a]);
+
+ // Case matching subtype doesn't cover supertype.
+ expectReportErrors(a, [b], 'A is not exhaustively matched by B.');
+ expectReportErrors(b, [b]);
+ expectReportErrors(d, [b]);
+ expectReportErrors(e, [b]);
+
+ // Matching subtypes of sealed type is exhaustive.
+ expectReportErrors(a, [b, c]);
+ expectReportErrors(a, [d, e, f]);
+ expectReportErrors(a, [b, f]);
+ expectReportErrors(a, [c, d], 'A is not exhaustively matched by C|D.');
+ expectReportErrors(f, [g, h], 'F is not exhaustively matched by G|H.');
+ });
+
+ test('unreachable case', () {
+ // Same type.
+ expectReportErrors(b, [b, b], 'Case #2 B is covered by B.');
+
+ // Previous case is supertype.
+ expectReportErrors(b, [a, b], 'Case #2 B is covered by A.');
+
+ // Previous subtype cases cover sealed supertype.
+ expectReportErrors(a, [b, c, a], 'Case #3 A is covered by B|C.');
+ expectReportErrors(a, [d, e, f, a], 'Case #4 A is covered by D|E|F.');
+ expectReportErrors(a, [b, f, a], 'Case #3 A is covered by B|F.');
+ expectReportErrors(a, [c, d, a]);
+
+ // Previous subtype cases do not cover unsealed supertype.
+ expectReportErrors(f, [g, h, f]);
+ });
+
+ test('covered record destructuring', () {
+ var r = StaticType('R', fields: {'x': a, 'y': a, 'z': a});
+
+ // Wider field is not covered.
+ expectReportErrors(r, [
+ {'x': b},
+ {'x': a}
+ ]);
+
+ // Narrower field is covered.
+ expectReportErrors(
+ r,
+ [
+ {'x': a},
+ {'x': b}
+ ],
+ 'Case #2 (x: B) is covered by (x: A).');
+ });
+
+ test('nullable sealed', () {
+ // (A)
+ // / \
+ // B (C)
+ // / \
+ // D E
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', isSealed: true, inherits: [a]);
+ var d = StaticType('D', inherits: [c]);
+ var e = StaticType('E', inherits: [c]);
+
+ // Must cover null.
+ expectReportErrors(
+ a.nullable, [b, d, e], 'A? is not exhaustively matched by B|D|E.');
+
+ // Can cover null with any nullable subtype.
+ expectReportErrors(a.nullable, [b.nullable, c]);
+ expectReportErrors(a.nullable, [b, c.nullable]);
+ expectReportErrors(a.nullable, [b, d.nullable, e]);
+ expectReportErrors(a.nullable, [b, d, e.nullable]);
+
+ // Can cover null with a null space.
+ expectReportErrors(a.nullable, [b, c, StaticType.nullType]);
+ expectReportErrors(a.nullable, [b, d, e, StaticType.nullType]);
+
+ // Nullable covers the non-null.
+ expectReportErrors(
+ a.nullable, [a.nullable, a], 'Case #2 A is covered by A?.');
+ expectReportErrors(
+ b.nullable, [a.nullable, b], 'Case #2 B is covered by A?.');
+
+ // Nullable covers null.
+ expectReportErrors(a.nullable, [a.nullable, StaticType.nullType],
+ 'Case #2 Null is covered by A?.');
+ expectReportErrors(b.nullable, [a.nullable, StaticType.nullType],
+ 'Case #2 Null is covered by A?.');
+ });
+}
+
+void expectReportErrors(StaticType valueType, List<Object> cases,
+ [String errors = '']) {
+ expect(reportErrors(valueType, parseSpaces(cases)), errors);
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/static_type_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/static_type_test.dart
new file mode 100644
index 0000000..54df2c6
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/static_type_test.dart
@@ -0,0 +1,172 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+void main() {
+ group('isSubtypeOf()', () {
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+ var b2 = StaticType('B2', inherits: [a]);
+ var c = StaticType('C', inherits: [b]);
+ var d = StaticType('D', inherits: [c]);
+
+ test('subtype includes self', () {
+ expect(a.isSubtypeOf(a), isTrue);
+ expect(b.isSubtypeOf(b), isTrue);
+ expect(c.isSubtypeOf(c), isTrue);
+ expect(d.isSubtypeOf(d), isTrue);
+ });
+
+ test('immediate', () {
+ expect(a.isSubtypeOf(b), isFalse);
+ expect(b.isSubtypeOf(a), isTrue);
+
+ expect(b.isSubtypeOf(c), isFalse);
+ expect(c.isSubtypeOf(b), isTrue);
+
+ expect(c.isSubtypeOf(d), isFalse);
+ expect(d.isSubtypeOf(c), isTrue);
+ });
+
+ test('transitive', () {
+ expect(a.isSubtypeOf(c), isFalse);
+ expect(c.isSubtypeOf(a), isTrue);
+
+ expect(b.isSubtypeOf(d), isFalse);
+ expect(d.isSubtypeOf(b), isTrue);
+
+ expect(a.isSubtypeOf(d), isFalse);
+ expect(d.isSubtypeOf(a), isTrue);
+ });
+
+ test('unrelated', () {
+ expect(b.isSubtypeOf(b2), isFalse);
+ expect(b2.isSubtypeOf(b), isFalse);
+
+ expect(c.isSubtypeOf(b2), isFalse);
+ expect(b2.isSubtypeOf(c), isFalse);
+
+ expect(d.isSubtypeOf(b2), isFalse);
+ expect(b2.isSubtypeOf(d), isFalse);
+ });
+
+ test('multiple supertypes', () {
+ // I1 I2 I3
+ // \ / \ /
+ // I12 I23
+ // \/
+ // I123
+ var i1 = StaticType('I1');
+ var i2 = StaticType('I2');
+ var i3 = StaticType('I3');
+ var i12 = StaticType('I12', inherits: [i1, i2]);
+ var i23 = StaticType('I12', inherits: [i2, i3]);
+ var i123 = StaticType('I12', inherits: [i12, i23]);
+
+ expect(i1.isSubtypeOf(i2), isFalse);
+ expect(i2.isSubtypeOf(i1), isFalse);
+ expect(i2.isSubtypeOf(i3), isFalse);
+ expect(i3.isSubtypeOf(i2), isFalse);
+ expect(i1.isSubtypeOf(i3), isFalse);
+ expect(i3.isSubtypeOf(i1), isFalse);
+
+ expect(i1.isSubtypeOf(i12), isFalse);
+ expect(i12.isSubtypeOf(i1), isTrue);
+ expect(i2.isSubtypeOf(i12), isFalse);
+ expect(i12.isSubtypeOf(i2), isTrue);
+ expect(i3.isSubtypeOf(i12), isFalse);
+ expect(i12.isSubtypeOf(i3), isFalse);
+
+ expect(i1.isSubtypeOf(i23), isFalse);
+ expect(i23.isSubtypeOf(i1), isFalse);
+ expect(i2.isSubtypeOf(i23), isFalse);
+ expect(i23.isSubtypeOf(i2), isTrue);
+ expect(i3.isSubtypeOf(i23), isFalse);
+ expect(i23.isSubtypeOf(i3), isTrue);
+
+ expect(i1.isSubtypeOf(i123), isFalse);
+ expect(i123.isSubtypeOf(i1), isTrue);
+ expect(i2.isSubtypeOf(i123), isFalse);
+ expect(i123.isSubtypeOf(i2), isTrue);
+ expect(i3.isSubtypeOf(i123), isFalse);
+ expect(i123.isSubtypeOf(i3), isTrue);
+ expect(i12.isSubtypeOf(i123), isFalse);
+ expect(i123.isSubtypeOf(i12), isTrue);
+ expect(i23.isSubtypeOf(i123), isFalse);
+ expect(i123.isSubtypeOf(i23), isTrue);
+ });
+
+ test('nullable', () {
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a]);
+
+ expect(StaticType.nullType.isSubtypeOf(a), isFalse);
+ expect(StaticType.nullType.isSubtypeOf(b), isFalse);
+ expect(StaticType.nullType.isSubtypeOf(a.nullable), isTrue);
+ expect(StaticType.nullType.isSubtypeOf(b.nullable), isTrue);
+
+ expect(a.isSubtypeOf(StaticType.nullType), isFalse);
+ expect(b.isSubtypeOf(StaticType.nullType), isFalse);
+ expect(a.nullable.isSubtypeOf(StaticType.nullType), isFalse);
+ expect(b.nullable.isSubtypeOf(StaticType.nullType), isFalse);
+
+ expect(a.isSubtypeOf(a.nullable), isTrue);
+ expect(a.nullable.isSubtypeOf(a), isFalse);
+ expect(a.nullable.isSubtypeOf(a.nullable), isTrue);
+
+ expect(a.isSubtypeOf(b.nullable), isFalse);
+ expect(a.nullable.isSubtypeOf(b), isFalse);
+ expect(a.nullable.isSubtypeOf(b.nullable), isFalse);
+
+ expect(b.isSubtypeOf(a.nullable), isTrue);
+ expect(b.nullable.isSubtypeOf(a), isFalse);
+ expect(b.nullable.isSubtypeOf(a.nullable), isTrue);
+ });
+ });
+
+ test('fields', () {
+ var a = StaticType('A');
+ var b = StaticType('B');
+ var c = StaticType('C', fields: {'x': a, 'y': b});
+ var d = StaticType('D', fields: {'w': a});
+ var e = StaticType('E', inherits: [c, d], fields: {'z': b});
+
+ expect(a.fields, isEmpty);
+ expect(b.fields, isEmpty);
+
+ expect(c.fields, hasLength(2));
+ expect(c.fields['x'], a);
+ expect(c.fields['y'], b);
+
+ // Fields are inherited.
+ expect(e.fields, hasLength(4));
+ expect(e.fields['x'], a);
+ expect(e.fields['y'], b);
+ expect(e.fields['w'], a);
+ expect(e.fields['z'], b);
+
+ // Overridden field types win.
+ var f = StaticType('F', fields: {'x': a});
+ var g = StaticType('G', inherits: [f], fields: {'x': b});
+ expect(g.fields, hasLength(1));
+ expect(g.fields['x'], b);
+ });
+
+ test('subtypes', () {
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [c]);
+
+ // Gets subtypes for sealed type.
+ var aSubtypes = a.subtypes.toList();
+ expect(aSubtypes, unorderedEquals([b, c]));
+
+ // And unsealed.
+ var cSubtypes = c.subtypes.toList();
+ expect(cSubtypes, unorderedEquals([d]));
+ });
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/subtract_test.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/subtract_test.dart
new file mode 100644
index 0000000..5a09217
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/subtract_test.dart
@@ -0,0 +1,253 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/subtract.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+ group('empty', () {
+ var a = StaticType('A');
+ var b = StaticType('B', inherits: [a], fields: {'x': a, 'y': a});
+ var c = StaticType('C', inherits: [a]);
+
+ expectSubtract('∅', '∅', '∅');
+
+ // Subtracting from empty stays empty.
+ expectSubtract('∅', a, '∅');
+ expectSubtract('∅', [b, c], '∅');
+ expectSubtract('∅', {'x': a}, '∅');
+ expectSubtract('∅', ty(b, {'x': a}), '∅');
+
+ // Subtracting empty leaves unchanged.
+ expectSubtract(a, '∅', 'A');
+ expectSubtract([b, c], '∅', 'B|C');
+ expectSubtract({'x': a}, '∅', '(x: A)');
+ expectSubtract(ty(b, {'x': a}), '∅', 'B(x: A)');
+ });
+
+ group('union with sealed types', () {
+ // (A)
+ // /|\
+ // B C(D)
+ // / \
+ // E F
+ var a = StaticType('A', isSealed: true);
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', isSealed: true, inherits: [a]);
+ var e = StaticType('E', inherits: [d]);
+ var f = StaticType('F', inherits: [d]);
+
+ expectSubtract(a, b, 'C|D');
+ expectSubtract(a, c, 'B|D');
+ expectSubtract(a, d, 'B|C');
+ expectSubtract(a, e, 'B|C|F');
+ expectSubtract(a, f, 'B|C|E');
+ expectSubtract(a, [b, c], 'D');
+ expectSubtract(a, [b, d], 'C');
+ expectSubtract(a, [b, e], 'C|F');
+
+ expectSubtract([b, c], b, 'C');
+ expectSubtract([b, c], c, 'B');
+ expectSubtract([b, c, d], b, 'C|D');
+ expectSubtract([b, c, d], c, 'B|D');
+ expectSubtract([b, c, d], d, 'B|C');
+
+ expectSubtract([b, c], [b, c], '∅');
+ expectSubtract([b, c], [b, d], 'C');
+ expectSubtract([b, d], [b, c], 'D');
+ expectSubtract([b, c, d], [b, c], 'D');
+
+ expectSubtract([b, d], e, 'B|F');
+ expectSubtract([b, e], d, 'B');
+ });
+
+ group('unsealed subtype', () {
+ // A B
+ // / \ /
+ // C D
+ // \ /
+ // E
+ var a = StaticType('A');
+ var b = StaticType('B');
+ var c = StaticType('C', inherits: [a]);
+ var d = StaticType('D', inherits: [a, b]);
+ var e = StaticType('E', inherits: [c, d]);
+
+ expectSubtract(a, a, '∅');
+ expectSubtract(a, b, 'A');
+ expectSubtract(a, c, 'A');
+ expectSubtract(a, d, 'A');
+ expectSubtract(a, e, 'A');
+
+ expectSubtract(b, a, 'B');
+ expectSubtract(b, b, '∅');
+ expectSubtract(b, c, 'B');
+ expectSubtract(b, d, 'B');
+ expectSubtract(b, e, 'B');
+
+ expectSubtract(c, a, '∅');
+ expectSubtract(c, b, 'C');
+ expectSubtract(c, c, '∅');
+ expectSubtract(c, d, 'C');
+ expectSubtract(c, e, 'C');
+
+ expectSubtract(d, a, '∅');
+ expectSubtract(d, b, '∅');
+ expectSubtract(d, c, 'D');
+ expectSubtract(d, d, '∅');
+ expectSubtract(d, e, 'D');
+
+ expectSubtract(e, a, '∅');
+ expectSubtract(e, b, '∅');
+ expectSubtract(e, c, '∅');
+ expectSubtract(e, d, '∅');
+ expectSubtract(e, e, '∅');
+ });
+
+ group('unsealed subtype and field', () {
+ // X A
+ // | |
+ // Y B
+ var x = StaticType('X');
+ var y = StaticType('Y', inherits: [x]);
+ var a = StaticType('A', fields: {'x': StaticType.top});
+ var b = StaticType('B', inherits: [a]);
+
+ Space A({required StaticType x}) => ty(a, {'x': x});
+ Space B({required StaticType x}) => ty(b, {'x': x});
+
+ expectSubtract(A(x: x), A(x: x), '∅');
+ expectSubtract(A(x: x), B(x: x), 'A(x: X)');
+ expectSubtract(B(x: x), A(x: x), '∅');
+ expectSubtract(B(x: x), B(x: x), '∅');
+
+ expectSubtract(A(x: x), A(x: y), 'A(x: X)');
+ expectSubtract(A(x: x), B(x: y), 'A(x: X)');
+ expectSubtract(B(x: x), A(x: y), 'B(x: X)');
+ expectSubtract(B(x: x), B(x: y), 'B(x: X)');
+
+ expectSubtract(A(x: y), A(x: x), '∅');
+ expectSubtract(A(x: y), B(x: x), 'A(x: Y)');
+ expectSubtract(B(x: y), A(x: x), '∅');
+ expectSubtract(B(x: y), B(x: x), '∅');
+
+ expectSubtract(A(x: y), A(x: y), '∅');
+ expectSubtract(A(x: y), B(x: y), 'A(x: Y)');
+ expectSubtract(B(x: y), A(x: y), '∅');
+ expectSubtract(B(x: y), B(x: y), '∅');
+
+ expectSubtract(A(x: x), a, '∅');
+ expectSubtract(A(x: x), b, 'A(x: X)');
+ expectSubtract(B(x: x), a, '∅');
+ expectSubtract(B(x: x), b, '∅');
+ expectSubtract(a, A(x: x), 'A');
+ expectSubtract(b, A(x: x), 'B');
+ expectSubtract(a, B(x: x), 'A');
+ expectSubtract(b, B(x: x), 'B');
+ });
+
+ group('sealed subtype and field', () {
+ // (X) (A)
+ // /|\ /|\
+ // W Y Z B C D
+ var x = StaticType('X', isSealed: true);
+ StaticType('W', inherits: [x]);
+ var y = StaticType('Y', inherits: [x]);
+ StaticType('Z', inherits: [x]);
+ var a = StaticType('A', isSealed: true, fields: {'x': StaticType.top});
+ var b = StaticType('B', inherits: [a]);
+ StaticType('C', inherits: [a]);
+ StaticType('D', inherits: [a]);
+
+ Space A({required StaticType x}) => ty(a, {'x': x});
+ Space B({required StaticType x}) => ty(b, {'x': x});
+
+ expectSubtract(A(x: x), A(x: x), '∅');
+ expectSubtract(A(x: x), B(x: x), 'C(x: X)|D(x: X)');
+ expectSubtract(B(x: x), A(x: x), '∅');
+ expectSubtract(B(x: x), B(x: x), '∅');
+
+ expectSubtract(A(x: x), A(x: y), 'A(x: W|Z)');
+ expectSubtract(A(x: x), B(x: y), 'B(x: W|Z)|C(x: X)|D(x: X)');
+ expectSubtract(B(x: x), A(x: y), 'B(x: W|Z)');
+ expectSubtract(B(x: x), B(x: y), 'B(x: W|Z)');
+
+ expectSubtract(A(x: y), A(x: x), '∅');
+ expectSubtract(A(x: y), B(x: x), 'C(x: Y)|D(x: Y)');
+ expectSubtract(B(x: y), A(x: x), '∅');
+ expectSubtract(B(x: y), B(x: x), '∅');
+
+ expectSubtract(A(x: y), A(x: y), '∅');
+ expectSubtract(A(x: y), B(x: y), 'C(x: Y)|D(x: Y)');
+ expectSubtract(B(x: y), A(x: y), '∅');
+ expectSubtract(B(x: y), B(x: y), '∅');
+
+ expectSubtract(A(x: x), a, '∅');
+ expectSubtract(A(x: x), b, 'C(x: X)|D(x: X)');
+ expectSubtract(B(x: x), a, '∅');
+ expectSubtract(B(x: x), b, '∅');
+
+ // Note that these don't specialize x to "W|Z" because it's declared type
+ // is top, which isn't sealed.
+ expectSubtract(a, A(x: x), 'A');
+ expectSubtract(b, A(x: x), 'B');
+ expectSubtract(a, B(x: x), 'B|C|D');
+ expectSubtract(b, B(x: x), 'B');
+ });
+
+ group('sealed subtype and field', () {
+ // (X) (A)
+ // /|\ /|\
+ // W Y Z B C D
+ var x = StaticType('X', isSealed: true);
+ var w = StaticType('W', inherits: [x]);
+ var y = StaticType('Y', inherits: [x]);
+ var z = StaticType('Z', inherits: [x]);
+ var a = StaticType('A', isSealed: true, fields: {'x': x, 'y': x, 'z': x});
+ var b = StaticType('B', inherits: [a]);
+ var c = StaticType('C', inherits: [a]);
+ StaticType('D', inherits: [a]);
+
+ Space A({StaticType? x, StaticType? y, StaticType? z}) => ty(a,
+ {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+ Space B({StaticType? x, StaticType? y, StaticType? z}) => ty(b,
+ {if (x != null) 'x': x, if (y != null) 'y': y, if (z != null) 'z': z});
+
+ // Fields only on left.
+ expectSubtract(A(x: x, y: y), a, '∅');
+ expectSubtract(A(x: x, y: y), b, 'C(x: X, y: Y)|D(x: X, y: Y)');
+ expectSubtract(B(x: x, y: y), a, '∅');
+ expectSubtract(B(x: x, y: y), c, 'B(x: X, y: Y)');
+
+ expectSubtract(A(x: w, y: z), a, '∅');
+ expectSubtract(A(x: w, y: z), b, 'C(x: W, y: Z)|D(x: W, y: Z)');
+ expectSubtract(B(x: w, y: z), a, '∅');
+ expectSubtract(B(x: w, y: z), c, 'B(x: W, y: Z)');
+
+ // Fields only on right.
+ expectSubtract(a, A(x: x, y: y), 'A(x: X, y: W|Z)');
+ expectSubtract(b, A(x: x, y: y), 'B(x: X, y: W|Z)');
+ expectSubtract(a, B(x: x, y: y), 'B(x: X, y: W|Z)|C|D');
+ expectSubtract(c, B(x: x, y: y), 'C');
+
+ expectSubtract(a, A(x: w, y: z), 'A(x: Y|Z, y: X)|A(x: X, y: W|Y)');
+ expectSubtract(b, A(x: w, y: z), 'B(x: Y|Z, y: X)|B(x: X, y: W|Y)');
+ expectSubtract(a, B(x: w, y: z), 'B(x: Y|Z, y: X)|B(x: X, y: W|Y)|C|D');
+ expectSubtract(c, B(x: w, y: z), 'C');
+ });
+}
+
+void expectSubtract(Object left, Object right, String expected) {
+ var leftSpace = parseSpace(left);
+ var rightSpace = parseSpace(right);
+ test('$leftSpace - $rightSpace', () {
+ var result = subtract(leftSpace, rightSpace);
+ expect(result.toString(), expected);
+ });
+}
diff --git a/pkg/_fe_analyzer_shared/test/exhaustiveness/utils.dart b/pkg/_fe_analyzer_shared/test/exhaustiveness/utils.dart
new file mode 100644
index 0000000..10cc5be
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/exhaustiveness/utils.dart
@@ -0,0 +1,102 @@
+// Copyright (c) 2022, 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.
+
+import 'package:_fe_analyzer_shared/src/exhaustiveness/exhaustive.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/space.dart';
+import 'package:_fe_analyzer_shared/src/exhaustiveness/static_type.dart';
+import 'package:test/test.dart';
+
+/// Test that [spaces] is exhaustive over [value].
+void expectExhaustive(Space value, List<Space> spaces) {
+ _expectExhaustive(value, spaces, true);
+}
+
+/// Test that [cases] are exhaustive over [type] if and only if all cases are
+/// included and that all subsets of the cases are not exhaustive.
+void expectExhaustiveOnlyAll(StaticType type, List<Object> cases) {
+ _testCases(type, cases, true);
+}
+
+/// Test that [cases] are not exhaustive over [type]. Also test that omitting
+/// each case is still not exhaustive.
+void expectNeverExhaustive(StaticType type, List<Object> cases) {
+ _testCases(type, cases, false);
+}
+
+/// Test that [spaces] is not exhaustive over [value].
+void expectNotExhaustive(Space value, List<Space> spaces) {
+ _expectExhaustive(value, spaces, false);
+}
+
+Map<String, Space> fieldsToSpace(Map<String, Object> fields) =>
+ fields.map((key, value) => MapEntry(key, parseSpace(value)));
+
+Space parseSpace(Object object) {
+ if (object is Space) return object;
+ if (object == '∅') return Space.empty;
+ if (object is StaticType) return Space(object);
+ if (object is List<Object>) {
+ return Space.union(object.map(parseSpace).toList());
+ }
+ if (object is Map<String, Object>) {
+ return Space.record(fieldsToSpace(object));
+ }
+
+ throw ArgumentError('Invalid space $object');
+}
+
+/// Parse a list of spaces using [parseSpace].
+List<Space> parseSpaces(List<Object> objects) =>
+ objects.map(parseSpace).toList();
+
+/// Make a record space with the given fields.
+Space rec({Object? w, Object? x, Object? y, Object? z}) => Space.record({
+ if (w != null) 'w': parseSpace(w),
+ if (x != null) 'x': parseSpace(x),
+ if (y != null) 'y': parseSpace(y),
+ if (z != null) 'z': parseSpace(z)
+ });
+
+/// Make a [Space] with [type] and [fields].
+Space ty(StaticType type, Map<String, Object> fields) =>
+ Space(type, fieldsToSpace(fields));
+
+void _checkExhaustive(Space value, List<Space> spaces, bool expectation) {
+ var actual = isExhaustive(value, spaces);
+ if (expectation != actual) {
+ if (expectation) {
+ fail('Expected $spaces to cover $value but did not.');
+ } else {
+ fail('Expected $spaces to not cover $value but did.');
+ }
+ }
+}
+
+void _expectExhaustive(Space value, List<Space> spaces, bool expectation) {
+ test(
+ '$value - ${spaces.join(' - ')} ${expectation ? 'is' : 'is not'} '
+ 'exhaustive', () {
+ _checkExhaustive(value, spaces, expectation);
+ });
+}
+
+/// Test that [cases] are not exhaustive over [type].
+void _testCases(StaticType type, List<Object> cases, bool expectation) {
+ var valueSpace = Space(type);
+ var spaces = parseSpaces(cases);
+
+ test('$type with all cases', () {
+ _checkExhaustive(valueSpace, spaces, expectation);
+ });
+
+ // With any single case removed, should also not be exhaustive.
+ for (var i = 0; i < spaces.length; i++) {
+ var filtered = spaces.toList();
+ filtered.removeAt(i);
+
+ test('$type without case ${spaces[i]}', () {
+ _checkExhaustive(valueSpace, filtered, false);
+ });
+ }
+}
diff --git a/pkg/_js_interop_checks/lib/src/transformations/static_interop_class_eraser.dart b/pkg/_js_interop_checks/lib/src/transformations/static_interop_class_eraser.dart
index 324a97d..e4ede99 100644
--- a/pkg/_js_interop_checks/lib/src/transformations/static_interop_class_eraser.dart
+++ b/pkg/_js_interop_checks/lib/src/transformations/static_interop_class_eraser.dart
@@ -120,8 +120,7 @@
signatureType.declaredNullability,
namedParameters: signatureType.namedParameters,
typeParameters: signatureType.typeParameters,
- requiredParameterCount: signatureType.requiredParameterCount,
- typedefType: signatureType.typedefType);
+ requiredParameterCount: signatureType.requiredParameterCount);
}
return newProcedure;
}
diff --git a/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart b/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart
index f98377e..71a53d6 100644
--- a/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart
+++ b/pkg/analysis_server/lib/src/services/snippets/dart/flutter_snippet_producers.dart
@@ -218,8 +218,8 @@
returnType: VoidTypeImpl.instance,
bodyWriter: () {
builder.writeln('{');
- builder.writeln(' super.dispose();');
builder.writeln(' _controller.dispose();');
+ builder.writeln(' super.dispose();');
builder.writeln(' }');
},
);
diff --git a/pkg/analysis_server/test/lsp/completion_dart_test.dart b/pkg/analysis_server/test/lsp/completion_dart_test.dart
index 40f2f70..ff5a000 100644
--- a/pkg/analysis_server/test/lsp/completion_dart_test.dart
+++ b/pkg/analysis_server/test/lsp/completion_dart_test.dart
@@ -2959,8 +2959,8 @@
@override
void dispose() {
- super.dispose();
_controller.dispose();
+ super.dispose();
}
@override
diff --git a/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart b/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart
index 16423ce..61a2ca0 100644
--- a/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart
+++ b/pkg/analysis_server/test/services/snippets/dart/flutter_snippet_producers_test.dart
@@ -211,8 +211,8 @@
@override
void dispose() {
- super.dispose();
_controller.dispose();
+ super.dispose();
}
@override
@@ -263,8 +263,8 @@
@override
void dispose() {
- super.dispose();
_controller.dispose();
+ super.dispose();
}
@override
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index d089ded..e695ae7 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -35,7 +35,7 @@
import 'package:analyzer/src/error/todo_finder.dart';
import 'package:analyzer/src/error/unicode_text_verifier.dart';
import 'package:analyzer/src/error/unused_local_elements_verifier.dart';
-import 'package:analyzer/src/generated/declaration_resolver.dart';
+import 'package:analyzer/src/generated/element_walker.dart';
import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/error_verifier.dart';
import 'package:analyzer/src/generated/ffi_verifier.dart';
diff --git a/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart b/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
index 71e14b9..7e108f6 100644
--- a/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
@@ -33,7 +33,7 @@
import 'package:analyzer/src/error/todo_finder.dart';
import 'package:analyzer/src/error/unicode_text_verifier.dart';
import 'package:analyzer/src/error/unused_local_elements_verifier.dart';
-import 'package:analyzer/src/generated/declaration_resolver.dart';
+import 'package:analyzer/src/generated/element_walker.dart';
import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/error_verifier.dart';
import 'package:analyzer/src/generated/resolver.dart';
diff --git a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
index cb2de85..781f48e 100644
--- a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
@@ -21,7 +21,7 @@
import 'package:analyzer/src/dart/resolver/named_type_resolver.dart';
import 'package:analyzer/src/dart/resolver/scope.dart';
import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/declaration_resolver.dart';
+import 'package:analyzer/src/generated/element_walker.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
class ElementHolder {
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/element_walker.dart
similarity index 87%
rename from pkg/analyzer/lib/src/generated/declaration_resolver.dart
rename to pkg/analyzer/lib/src/generated/element_walker.dart
index 041fc62..aafabade 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_walker.dart
@@ -2,9 +2,6 @@
// 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.
-// See: https://github.com/dart-lang/linter/issues/3345
-// ignore_for_file: prefer_initializing_formals
-
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/src/dart/element/element.dart';
@@ -41,9 +38,8 @@
/// Creates an [ElementWalker] which walks the child elements of a class
/// element.
- ElementWalker.forClass(ClassElement element)
- : element = element,
- _accessors = element.accessors.where(_isNotSynthetic).toList(),
+ ElementWalker.forClass(ClassElement this.element)
+ : _accessors = element.accessors.where(_isNotSynthetic).toList(),
_constructors = element.isMixinApplication
? null
: element.constructors.where(_isNotSynthetic).toList(),
@@ -53,10 +49,9 @@
/// Creates an [ElementWalker] which walks the child elements of a compilation
/// unit element.
- ElementWalker.forCompilationUnit(CompilationUnitElementImpl element,
+ ElementWalker.forCompilationUnit(CompilationUnitElementImpl this.element,
{this.libraryFilePath, this.unitFilePath})
- : element = element,
- _accessors = element.accessors.where(_isNotSynthetic).toList(),
+ : _accessors = element.accessors.where(_isNotSynthetic).toList(),
_classes = element.classes,
_enums = element.enums,
_extensions = element.extensions,
@@ -67,46 +62,40 @@
/// Creates an [ElementWalker] which walks the child elements of a compilation
/// unit element.
- ElementWalker.forExecutable(ExecutableElement element)
- : element = element,
- _functions = const <ExecutableElement>[],
+ ElementWalker.forExecutable(ExecutableElement this.element)
+ : _functions = const <ExecutableElement>[],
_parameters = element.parameters,
_typeParameters = element.typeParameters;
/// Creates an [ElementWalker] which walks the child elements of an extension
/// element.
- ElementWalker.forExtension(ExtensionElement element)
- : element = element,
- _accessors = element.accessors.where(_isNotSynthetic).toList(),
+ ElementWalker.forExtension(ExtensionElement this.element)
+ : _accessors = element.accessors.where(_isNotSynthetic).toList(),
_functions = element.methods,
_typeParameters = element.typeParameters,
_variables = element.fields.where(_isNotSynthetic).toList();
/// Creates an [ElementWalker] which walks the child elements of a typedef
/// element.
- ElementWalker.forGenericFunctionType(GenericFunctionTypeElement element)
- : element = element,
- _parameters = element.parameters,
+ ElementWalker.forGenericFunctionType(GenericFunctionTypeElement this.element)
+ : _parameters = element.parameters,
_typeParameters = element.typeParameters;
/// Creates an [ElementWalker] which walks the child elements of a typedef
/// element defined using a generic function type.
- ElementWalker.forGenericTypeAlias(TypeAliasElement element)
- : element = element,
- _typeParameters = element.typeParameters;
+ ElementWalker.forGenericTypeAlias(TypeAliasElement this.element)
+ : _typeParameters = element.typeParameters;
/// Creates an [ElementWalker] which walks the child elements of a parameter
/// element.
- ElementWalker.forParameter(ParameterElement element)
- : element = element,
- _parameters = element.parameters,
+ ElementWalker.forParameter(ParameterElement this.element)
+ : _parameters = element.parameters,
_typeParameters = element.typeParameters;
/// Creates an [ElementWalker] which walks the child elements of a typedef
/// element.
- ElementWalker.forTypedef(TypeAliasElement element)
- : element = element,
- _parameters =
+ ElementWalker.forTypedef(TypeAliasElement this.element)
+ : _parameters =
(element.aliasedElement as GenericFunctionTypeElement).parameters,
_typeParameters = element.typeParameters;
diff --git a/pkg/compiler/lib/src/common/elements.dart b/pkg/compiler/lib/src/common/elements.dart
index 482fe9a..a66fe73 100644
--- a/pkg/compiler/lib/src/common/elements.dart
+++ b/pkg/compiler/lib/src/common/elements.dart
@@ -2,280 +2,145 @@
// 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.
-// @dart = 2.10
-
import '../common.dart';
-import '../constants/common_elements_for_constants.dart'
- as common_elements_for_constants;
import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../elements/entities.dart';
import '../elements/types.dart';
import '../inferrer/abstract_value_domain.dart';
-import '../js_backend/native_data.dart' show NativeBasicData;
-import '../js_model/locals.dart';
+import '../js_backend/native_data_interfaces.dart' show NativeBasicData;
+import '../js_model/locals_interfaces.dart';
import '../universe/selector.dart' show Selector;
import 'names.dart' show Identifiers, Uris;
/// The common elements and types in Dart.
-abstract class CommonElements
- implements
- CommonElementsForDartTypes,
- common_elements_for_constants.CommonElements {
- @override
+abstract class CommonElements {
final DartTypes dartTypes;
final ElementEnvironment _env;
- ClassEntity _objectClass;
- ClassEntity _boolClass;
- ClassEntity _numClass;
- ClassEntity _intClass;
- ClassEntity _doubleClass;
- ClassEntity _stringClass;
- ClassEntity _functionClass;
- ClassEntity _resourceClass;
- ClassEntity _symbolClass;
- ClassEntity _nullClass;
- ClassEntity _typeClass;
- ClassEntity _stackTraceClass;
- ClassEntity _listClass;
- ClassEntity _setClass;
- ClassEntity _mapClass;
- ClassEntity _unmodifiableSetClass;
- ClassEntity _iterableClass;
- ClassEntity _futureClass;
- ClassEntity _streamClass;
- LibraryEntity _coreLibrary;
- LibraryEntity _asyncLibrary;
- LibraryEntity _mirrorsLibrary;
- LibraryEntity _typedDataLibrary;
- LibraryEntity _jsHelperLibrary;
- LibraryEntity _lateHelperLibrary;
- LibraryEntity _foreignLibrary;
- LibraryEntity _rtiLibrary;
- LibraryEntity _interceptorsLibrary;
- LibraryEntity _internalLibrary;
- LibraryEntity _dartJsAnnotationsLibrary;
- LibraryEntity _dartJsLibrary;
- LibraryEntity _packageJsLibrary;
- ClassEntity _typedDataClass;
- ConstructorEntity _symbolConstructorTarget;
+ ClassEntity? _symbolClass;
+ ConstructorEntity? _symbolConstructorTarget;
bool _computedSymbolConstructorDependencies = false;
- ConstructorEntity _symbolConstructorImplementationTarget;
- FunctionEntity _identicalFunction;
- ClassEntity _mapLiteralClass;
- ConstructorEntity _mapLiteralConstructor;
- ConstructorEntity _mapLiteralConstructorEmpty;
- FunctionEntity _mapLiteralUntypedMaker;
- FunctionEntity _mapLiteralUntypedEmptyMaker;
- ClassEntity _setLiteralClass;
- ConstructorEntity _setLiteralConstructor;
- ConstructorEntity _setLiteralConstructorEmpty;
- FunctionEntity _setLiteralUntypedMaker;
- FunctionEntity _setLiteralUntypedEmptyMaker;
- FunctionEntity _objectNoSuchMethod;
- FunctionEntity _syncStarIterableFactory;
- FunctionEntity _asyncAwaitCompleterFactory;
- FunctionEntity _asyncStarStreamControllerFactory;
- ClassEntity _jsInterceptorClass;
- ClassEntity _jsStringClass;
- ClassEntity _jsArrayClass;
- ClassEntity _jsNumberClass;
- ClassEntity _jsIntClass;
- ClassEntity _jsNumNotIntClass;
- ClassEntity _jsNullClass;
- ClassEntity _jsBoolClass;
- ClassEntity _jsPlainJavaScriptObjectClass;
- ClassEntity _jsUnknownJavaScriptObjectClass;
- ClassEntity _jsJavaScriptFunctionClass;
- ClassEntity _jsLegacyJavaScriptObjectClass;
- ClassEntity _jsJavaScriptObjectClass;
- ClassEntity _jsIndexableClass;
- ClassEntity _jsMutableIndexableClass;
- ClassEntity _jsMutableArrayClass;
- ClassEntity _jsFixedArrayClass;
- ClassEntity _jsExtendableArrayClass;
- ClassEntity _jsUnmodifiableArrayClass;
- ClassEntity _jsPositiveIntClass;
- ClassEntity _jsUInt32Class;
- ClassEntity _jsUInt31Class;
- FunctionEntity _getNativeInterceptorMethod;
- ConstructorEntity _jsArrayTypedConstructor;
- ClassEntity _closureClass;
- ClassEntity _closureClass0Args;
- ClassEntity _closureClass2Args;
- ClassEntity _boundClosureClass;
- ClassEntity _typeLiteralClass;
- ClassEntity _constMapLiteralClass;
- ClassEntity _constSetLiteralClass;
- ClassEntity _jsInvocationMirrorClass;
- ClassEntity _requiredSentinelClass;
- MemberEntity _invocationTypeArgumentGetter;
- ClassEntity _jsIndexingBehaviorInterface;
- ClassEntity _nativeAnnotationClass;
- FunctionEntity _assertTest;
- FunctionEntity _assertThrow;
- FunctionEntity _assertHelper;
- FunctionEntity _assertUnreachableMethod;
- FunctionEntity _getIsolateAffinityTagMarker;
- FunctionEntity _requiresPreambleMarker;
- FunctionEntity _rawStartupMetrics;
- FunctionEntity _setArrayType;
- FunctionEntity _findType;
- FunctionEntity _instanceType;
- FunctionEntity _arrayInstanceType;
- FunctionEntity _simpleInstanceType;
- FunctionEntity _typeLiteralMaker;
- FunctionEntity _checkTypeBound;
- FieldEntity _rtiAsField;
- FieldEntity _rtiIsField;
- FieldEntity _rtiRestField;
- FieldEntity _rtiPrecomputed1Field;
- FunctionEntity _rtiEvalMethod;
- FunctionEntity _rtiBindMethod;
- FunctionEntity _rtiAddRulesMethod;
- FunctionEntity _rtiAddErasedTypesMethod;
- FunctionEntity _rtiAddTypeParameterVariancesMethod;
- FunctionEntity _generalIsTestImplementation;
- FunctionEntity _generalAsCheckImplementation;
- FunctionEntity _generalNullableAsCheckImplementation;
- FunctionEntity _specializedIsObject;
- FunctionEntity _specializedAsObject;
- FunctionEntity _generalNullableIsTestImplementation;
- ClassEntity _symbolImplementationClass;
- ClassEntity _externalNameClass;
- ClassEntity _jsGetNameEnum;
- FunctionEntity _jsAllowInterop1;
- FunctionEntity _jsAllowInterop2;
- FieldEntity _symbolImplementationField;
- FunctionEntity _cachedCheckConcurrentModificationError;
+ ConstructorEntity? _symbolConstructorImplementationTarget;
+ ClassEntity? _mapLiteralClass;
+ ClassEntity? _symbolImplementationClass;
+ FieldEntity? _symbolImplementationField;
CommonElements(this.dartTypes, this._env);
/// The `Object` class defined in 'dart:core'.
- ClassEntity get objectClass =>
- _objectClass ??= _findClass(coreLibrary, 'Object');
+ late final ClassEntity objectClass = _findClass(coreLibrary, 'Object')!;
/// The `bool` class defined in 'dart:core'.
- ClassEntity get boolClass => _boolClass ??= _findClass(coreLibrary, 'bool');
+ late final ClassEntity boolClass = _findClass(coreLibrary, 'bool')!;
/// The `num` class defined in 'dart:core'.
- ClassEntity get numClass => _numClass ??= _findClass(coreLibrary, 'num');
+ late final ClassEntity numClass = _findClass(coreLibrary, 'num')!;
/// The `int` class defined in 'dart:core'.
- ClassEntity get intClass => _intClass ??= _findClass(coreLibrary, 'int');
+ late final ClassEntity intClass = _findClass(coreLibrary, 'int')!;
/// The `double` class defined in 'dart:core'.
- ClassEntity get doubleClass =>
- _doubleClass ??= _findClass(coreLibrary, 'double');
+ late final ClassEntity doubleClass = _findClass(coreLibrary, 'double')!;
/// The `String` class defined in 'dart:core'.
- ClassEntity get stringClass =>
- _stringClass ??= _findClass(coreLibrary, 'String');
+ late final ClassEntity stringClass = _findClass(coreLibrary, 'String')!;
/// The `Function` class defined in 'dart:core'.
- ClassEntity get functionClass =>
- _functionClass ??= _findClass(coreLibrary, 'Function');
+ late final ClassEntity functionClass = _findClass(coreLibrary, 'Function')!;
/// The `Resource` class defined in 'dart:core'.
- ClassEntity get resourceClass =>
- _resourceClass ??= _findClass(coreLibrary, 'Resource');
+ late final ClassEntity resourceClass = _findClass(coreLibrary, 'Resource')!;
/// The `Symbol` class defined in 'dart:core'.
- ClassEntity get symbolClass =>
- _symbolClass ??= _findClass(coreLibrary, 'Symbol');
+ late final ClassEntity symbolClass = _findClass(coreLibrary, 'Symbol')!;
/// The `Null` class defined in 'dart:core'.
- ClassEntity get nullClass => _nullClass ??= _findClass(coreLibrary, 'Null');
+ late final ClassEntity nullClass = _findClass(coreLibrary, 'Null')!;
/// The `Type` class defined in 'dart:core'.
- ClassEntity get typeClass => _typeClass ??= _findClass(coreLibrary, 'Type');
+ late final ClassEntity typeClass = _findClass(coreLibrary, 'Type')!;
/// The `StackTrace` class defined in 'dart:core';
- ClassEntity get stackTraceClass =>
- _stackTraceClass ??= _findClass(coreLibrary, 'StackTrace');
+ late final ClassEntity stackTraceClass =
+ _findClass(coreLibrary, 'StackTrace')!;
/// The `List` class defined in 'dart:core';
- ClassEntity get listClass => _listClass ??= _findClass(coreLibrary, 'List');
+ late final ClassEntity listClass = _findClass(coreLibrary, 'List')!;
/// The `Set` class defined in 'dart:core';
- ClassEntity get setClass => _setClass ??= _findClass(coreLibrary, 'Set');
+ late final ClassEntity setClass = _findClass(coreLibrary, 'Set')!;
/// The `Map` class defined in 'dart:core';
- ClassEntity get mapClass => _mapClass ??= _findClass(coreLibrary, 'Map');
+ late final ClassEntity mapClass = _findClass(coreLibrary, 'Map')!;
/// The `Set` class defined in 'dart:core';
- ClassEntity get unmodifiableSetClass => _unmodifiableSetClass ??=
- _findClass(_env.lookupLibrary(Uris.dart_collection), '_UnmodifiableSet');
+ late final ClassEntity unmodifiableSetClass =
+ _findClass(_env.lookupLibrary(Uris.dart_collection), '_UnmodifiableSet')!;
/// The `Iterable` class defined in 'dart:core';
- ClassEntity get iterableClass =>
- _iterableClass ??= _findClass(coreLibrary, 'Iterable');
+ late final ClassEntity iterableClass = _findClass(coreLibrary, 'Iterable')!;
/// The `Future` class defined in 'async';.
- ClassEntity get futureClass =>
- _futureClass ??= _findClass(asyncLibrary, 'Future');
+ late final ClassEntity futureClass = _findClass(asyncLibrary, 'Future')!;
/// The `Stream` class defined in 'async';
- ClassEntity get streamClass =>
- _streamClass ??= _findClass(asyncLibrary, 'Stream');
+ late final ClassEntity streamClass = _findClass(asyncLibrary, 'Stream')!;
/// The dart:core library.
- LibraryEntity get coreLibrary =>
- _coreLibrary ??= _env.lookupLibrary(Uris.dart_core, required: true);
+ late final LibraryEntity coreLibrary =
+ _env.lookupLibrary(Uris.dart_core, required: true)!;
/// The dart:async library.
- LibraryEntity get asyncLibrary =>
- _asyncLibrary ??= _env.lookupLibrary(Uris.dart_async);
+ late final LibraryEntity? asyncLibrary = _env.lookupLibrary(Uris.dart_async);
/// The dart:mirrors library.
/// Null if the program doesn't access dart:mirrors.
- LibraryEntity get mirrorsLibrary =>
- _mirrorsLibrary ??= _env.lookupLibrary(Uris.dart_mirrors);
+ late final LibraryEntity? mirrorsLibrary =
+ _env.lookupLibrary(Uris.dart_mirrors);
/// The dart:typed_data library.
- LibraryEntity get typedDataLibrary =>
- _typedDataLibrary ??= _env.lookupLibrary(Uris.dart__native_typed_data);
+ late final LibraryEntity? typedDataLibrary =
+ _env.lookupLibrary(Uris.dart__native_typed_data);
/// The dart:_js_helper library.
- LibraryEntity get jsHelperLibrary =>
- _jsHelperLibrary ??= _env.lookupLibrary(Uris.dart__js_helper);
+ late final LibraryEntity? jsHelperLibrary =
+ _env.lookupLibrary(Uris.dart__js_helper);
/// The dart:_late_helper library
- LibraryEntity get lateHelperLibrary =>
- _lateHelperLibrary ??= _env.lookupLibrary(Uris.dart__late_helper);
+ late final LibraryEntity? lateHelperLibrary =
+ _env.lookupLibrary(Uris.dart__late_helper);
/// The dart:_interceptors library.
- LibraryEntity get interceptorsLibrary =>
- _interceptorsLibrary ??= _env.lookupLibrary(Uris.dart__interceptors);
+ late final LibraryEntity? interceptorsLibrary =
+ _env.lookupLibrary(Uris.dart__interceptors);
/// The dart:_foreign_helper library.
- LibraryEntity get foreignLibrary =>
- _foreignLibrary ??= _env.lookupLibrary(Uris.dart__foreign_helper);
+ late final LibraryEntity? foreignLibrary =
+ _env.lookupLibrary(Uris.dart__foreign_helper);
/// The dart:_rti library.
- LibraryEntity get rtiLibrary =>
- _rtiLibrary ??= _env.lookupLibrary(Uris.dart__rti, required: true);
+ late final LibraryEntity rtiLibrary =
+ _env.lookupLibrary(Uris.dart__rti, required: true)!;
/// The dart:_internal library.
- LibraryEntity get internalLibrary => _internalLibrary ??=
- _env.lookupLibrary(Uris.dart__internal, required: true);
+ late final LibraryEntity internalLibrary =
+ _env.lookupLibrary(Uris.dart__internal, required: true)!;
/// The dart:js library.
- LibraryEntity get dartJsLibrary =>
- _dartJsLibrary ??= _env.lookupLibrary(Uris.dart_js);
+ late final LibraryEntity? dartJsLibrary = _env.lookupLibrary(Uris.dart_js);
/// The package:js library.
- LibraryEntity get packageJsLibrary =>
- _packageJsLibrary ??= _env.lookupLibrary(Uris.package_js);
+ late final LibraryEntity? packageJsLibrary =
+ _env.lookupLibrary(Uris.package_js);
/// The dart:_js_annotations library.
- LibraryEntity get dartJsAnnotationsLibrary => _dartJsAnnotationsLibrary ??=
+ late final LibraryEntity? dartJsAnnotationsLibrary =
_env.lookupLibrary(Uris.dart__js_annotations);
/// The `NativeTypedData` class from dart:typed_data.
ClassEntity get typedDataClass =>
- _typedDataClass ??= _findClass(typedDataLibrary, 'NativeTypedData');
+ _findClass(typedDataLibrary, 'NativeTypedData')!;
/// Constructor of the `Symbol` class in dart:internal.
///
@@ -299,7 +164,7 @@
}
if (_symbolImplementationClass != null) {
_symbolConstructorTarget =
- _findConstructor(_symbolImplementationClass, '', required: false);
+ _findConstructor(_symbolImplementationClass!, '', required: false);
}
}
if (_symbolClass == null) {
@@ -317,15 +182,15 @@
/// Used to check for the constructor without computing it until it is likely
/// to be seen.
bool isSymbolConstructor(ConstructorEntity element) {
- assert(element != null);
+ assert((element as dynamic) != null); // TODO(48820): Remove.
_ensureSymbolConstructorDependencies();
return element == _symbolConstructorImplementationTarget ||
element == _symbolConstructorTarget;
}
/// The function `identical` in dart:core.
- FunctionEntity get identicalFunction =>
- _identicalFunction ??= _findLibraryMember(coreLibrary, 'identical');
+ late final FunctionEntity identicalFunction =
+ _findLibraryMember(coreLibrary, 'identical')!;
/// Whether [element] is the `Function.apply` method.
///
@@ -335,47 +200,38 @@
element.name == 'apply' && element.enclosingClass == functionClass;
/// The `dynamic` type.
- @override
- DynamicType get dynamicType => _env.dynamicType;
+ DynamicType get dynamicType => _env.dynamicType as DynamicType;
/// The `Object` type defined in 'dart:core'.
- @override // CommonElementsForDartTypes
InterfaceType get objectType => _getRawType(objectClass);
/// The `bool` type defined in 'dart:core'.
- @override
InterfaceType get boolType => _getRawType(boolClass);
/// The `num` type defined in 'dart:core'.
InterfaceType get numType => _getRawType(numClass);
/// The `int` type defined in 'dart:core'.
- @override // CommonElementsForDartTypes
InterfaceType get intType => _getRawType(intClass);
/// The `double` type defined in 'dart:core'.
- @override // CommonElementsForDartTypes
InterfaceType get doubleType => _getRawType(doubleClass);
/// The `String` type defined in 'dart:core'.
- @override
InterfaceType get stringType => _getRawType(stringClass);
/// The `Symbol` type defined in 'dart:core'.
InterfaceType get symbolType => _getRawType(symbolClass);
/// The `Function` type defined in 'dart:core'.
- @override // CommonElementsForDartTypes
InterfaceType get functionType => _getRawType(functionClass);
/// The `Null` type defined in 'dart:core'.
- @override // CommonElementsForDartTypes
InterfaceType get nullType => _getRawType(nullClass);
/// The `Type` type defined in 'dart:core'.
InterfaceType get typeType => _getRawType(typeClass);
- @override
InterfaceType get typeLiteralType => _getRawType(typeLiteralClass);
/// The `StackTrace` type defined in 'dart:core';
@@ -385,8 +241,7 @@
/// [elementType] as its type argument.
///
/// If no type argument is provided, the canonical raw type is returned.
- @override
- InterfaceType listType([DartType elementType]) {
+ InterfaceType listType([DartType? elementType]) {
if (elementType == null) {
return _getRawType(listClass);
}
@@ -397,7 +252,7 @@
/// [elementType] as its type argument.
///
/// If no type argument is provided, the canonical raw type is returned.
- InterfaceType setType([DartType elementType]) {
+ InterfaceType setType([DartType? elementType]) {
if (elementType == null) {
return _getRawType(setClass);
}
@@ -408,8 +263,8 @@
/// [keyType] and [valueType] as its type arguments.
///
/// If no type arguments are provided, the canonical raw type is returned.
- @override
- InterfaceType mapType([DartType keyType, DartType valueType]) {
+
+ InterfaceType mapType([DartType? keyType, DartType? valueType]) {
if (keyType == null && valueType == null) {
return _getRawType(mapClass);
} else if (keyType == null) {
@@ -417,14 +272,14 @@
} else if (valueType == null) {
valueType = dynamicType;
}
- return _createInterfaceType(mapClass, [keyType, valueType]);
+ return _createInterfaceType(mapClass, [keyType, valueType!]);
}
/// Returns an instance of the `Iterable` type defined in 'dart:core' with
/// [elementType] as its type argument.
///
/// If no type argument is provided, the canonical raw type is returned.
- InterfaceType iterableType([DartType elementType]) {
+ InterfaceType iterableType([DartType? elementType]) {
if (elementType == null) {
return _getRawType(iterableClass);
}
@@ -435,8 +290,8 @@
/// [elementType] as its type argument.
///
/// If no type argument is provided, the canonical raw type is returned.
- @override // CommonElementsForDartTypes
- InterfaceType futureType([DartType elementType]) {
+ // CommonElementsForDartTypes
+ InterfaceType futureType([DartType? elementType]) {
if (elementType == null) {
return _getRawType(futureClass);
}
@@ -447,30 +302,31 @@
/// [elementType] as its type argument.
///
/// If no type argument is provided, the canonical raw type is returned.
- InterfaceType streamType([DartType elementType]) {
+ InterfaceType streamType([DartType? elementType]) {
if (elementType == null) {
return _getRawType(streamClass);
}
return _createInterfaceType(streamClass, [elementType]);
}
- ClassEntity _findClass(LibraryEntity library, String name,
+ ClassEntity? _findClass(LibraryEntity? library, String name,
{bool required = true}) {
if (library == null) return null;
return _env.lookupClass(library, name, required: required);
}
- MemberEntity _findLibraryMember(LibraryEntity library, String name,
+ T? _findLibraryMember<T extends MemberEntity>(
+ LibraryEntity? library, String name,
{bool setter = false, bool required = true}) {
if (library == null) return null;
return _env.lookupLibraryMember(library, name,
- setter: setter, required: required);
+ setter: setter, required: required) as T?;
}
- MemberEntity _findClassMember(ClassEntity cls, String name,
+ T _findClassMember<T extends MemberEntity>(ClassEntity cls, String name,
{bool setter = false, bool required = true}) {
return _env.lookupLocalClassMember(cls, name,
- setter: setter, required: required);
+ setter: setter, required: required) as T;
}
ConstructorEntity _findConstructor(ClassEntity cls, String name,
@@ -490,13 +346,11 @@
return _env.createInterfaceType(cls, typeArguments);
}
- @override
InterfaceType getConstantListTypeFor(InterfaceType sourceType) =>
dartTypes.treatAsRawType(sourceType)
? _env.getRawType(jsArrayClass)
: _env.createInterfaceType(jsArrayClass, sourceType.typeArguments);
- @override
InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
{bool onlyStringKeys = false}) {
ClassEntity classElement =
@@ -508,7 +362,6 @@
}
}
- @override
InterfaceType getConstantSetTypeFor(InterfaceType sourceType) =>
dartTypes.treatAsRawType(sourceType)
? _env.getRawType(constSetLiteralClass)
@@ -517,12 +370,11 @@
/// Returns the field that holds the internal name in the implementation class
/// for `Symbol`.
- @override
+
FieldEntity get symbolField => _symbolImplementationField ??=
_env.lookupLocalClassMember(symbolImplementationClass, '_name',
- required: true);
+ required: true) as FieldEntity;
- @override
InterfaceType get symbolImplementationType =>
_env.getRawType(symbolImplementationClass);
@@ -535,85 +387,37 @@
_env.lookupLibrary(Uris.dart_collection), 'LinkedHashMap');
}
}
- return _mapLiteralClass;
+ return _mapLiteralClass!;
}
- void _ensureMapLiteralHelpers() {
- if (_mapLiteralConstructor != null) return;
+ late final ConstructorEntity mapLiteralConstructor =
+ _env.lookupConstructor(mapLiteralClass, '_literal');
+ late final ConstructorEntity mapLiteralConstructorEmpty =
+ _env.lookupConstructor(mapLiteralClass, '_empty');
+ late final FunctionEntity mapLiteralUntypedMaker =
+ _env.lookupLocalClassMember(mapLiteralClass, '_makeLiteral')
+ as FunctionEntity;
+ late final FunctionEntity mapLiteralUntypedEmptyMaker = _env
+ .lookupLocalClassMember(mapLiteralClass, '_makeEmpty') as FunctionEntity;
- _mapLiteralConstructor =
- _env.lookupConstructor(mapLiteralClass, '_literal');
- _mapLiteralConstructorEmpty =
- _env.lookupConstructor(mapLiteralClass, '_empty');
- _mapLiteralUntypedMaker =
- _env.lookupLocalClassMember(mapLiteralClass, '_makeLiteral');
- _mapLiteralUntypedEmptyMaker =
- _env.lookupLocalClassMember(mapLiteralClass, '_makeEmpty');
- }
+ late final ClassEntity setLiteralClass =
+ _findClass(_env.lookupLibrary(Uris.dart_collection), 'LinkedHashSet')!;
- ConstructorEntity get mapLiteralConstructor {
- _ensureMapLiteralHelpers();
- return _mapLiteralConstructor;
- }
+ late final ConstructorEntity setLiteralConstructor =
+ _env.lookupConstructor(setLiteralClass, '_literal');
+ late final ConstructorEntity setLiteralConstructorEmpty =
+ _env.lookupConstructor(setLiteralClass, '_empty');
+ late final FunctionEntity setLiteralUntypedMaker =
+ _env.lookupLocalClassMember(setLiteralClass, '_makeLiteral')
+ as FunctionEntity;
+ late final FunctionEntity setLiteralUntypedEmptyMaker = _env
+ .lookupLocalClassMember(setLiteralClass, '_makeEmpty') as FunctionEntity;
- ConstructorEntity get mapLiteralConstructorEmpty {
- _ensureMapLiteralHelpers();
- return _mapLiteralConstructorEmpty;
- }
-
- FunctionEntity get mapLiteralUntypedMaker {
- _ensureMapLiteralHelpers();
- return _mapLiteralUntypedMaker;
- }
-
- FunctionEntity get mapLiteralUntypedEmptyMaker {
- _ensureMapLiteralHelpers();
- return _mapLiteralUntypedEmptyMaker;
- }
-
- ClassEntity get setLiteralClass => _setLiteralClass ??=
- _findClass(_env.lookupLibrary(Uris.dart_collection), 'LinkedHashSet');
-
- void _ensureSetLiteralHelpers() {
- if (_setLiteralConstructor != null) return;
-
- _setLiteralConstructor =
- _env.lookupConstructor(setLiteralClass, '_literal');
- _setLiteralConstructorEmpty =
- _env.lookupConstructor(setLiteralClass, '_empty');
- _setLiteralUntypedMaker =
- _env.lookupLocalClassMember(setLiteralClass, '_makeLiteral');
- _setLiteralUntypedEmptyMaker =
- _env.lookupLocalClassMember(setLiteralClass, '_makeEmpty');
- }
-
- ConstructorEntity get setLiteralConstructor {
- _ensureSetLiteralHelpers();
- return _setLiteralConstructor;
- }
-
- ConstructorEntity get setLiteralConstructorEmpty {
- _ensureSetLiteralHelpers();
- return _setLiteralConstructorEmpty;
- }
-
- FunctionEntity get setLiteralUntypedMaker {
- _ensureSetLiteralHelpers();
- return _setLiteralUntypedMaker;
- }
-
- FunctionEntity get setLiteralUntypedEmptyMaker {
- _ensureSetLiteralHelpers();
- return _setLiteralUntypedEmptyMaker;
- }
-
- FunctionEntity get objectNoSuchMethod {
- return _objectNoSuchMethod ??=
- _env.lookupLocalClassMember(objectClass, Identifiers.noSuchMethod_);
- }
+ late final FunctionEntity objectNoSuchMethod = _env.lookupLocalClassMember(
+ objectClass, Identifiers.noSuchMethod_) as FunctionEntity;
bool isDefaultNoSuchMethodImplementation(FunctionEntity element) {
- ClassEntity classElement = element.enclosingClass;
+ ClassEntity? classElement = element.enclosingClass;
return classElement == objectClass ||
classElement == jsInterceptorClass ||
classElement == jsNullClass;
@@ -621,10 +425,10 @@
// From dart:async
ClassEntity _findAsyncHelperClass(String name) =>
- _findClass(asyncLibrary, name);
+ _findClass(asyncLibrary, name)!;
FunctionEntity _findAsyncHelperFunction(String name) =>
- _findLibraryMember(asyncLibrary, name);
+ _findLibraryMember(asyncLibrary, name)!;
FunctionEntity get asyncHelperStartSync =>
_findAsyncHelperFunction("_asyncStartSync");
@@ -642,13 +446,15 @@
_findAsyncHelperFunction("_wrapJsFunctionForAsync");
FunctionEntity get yieldStar => _env.lookupLocalClassMember(
- _findAsyncHelperClass("_IterationMarker"), "yieldStar");
+ _findAsyncHelperClass("_IterationMarker"), "yieldStar") as FunctionEntity;
FunctionEntity get yieldSingle => _env.lookupLocalClassMember(
- _findAsyncHelperClass("_IterationMarker"), "yieldSingle");
+ _findAsyncHelperClass("_IterationMarker"), "yieldSingle")
+ as FunctionEntity;
FunctionEntity get syncStarUncaughtError => _env.lookupLocalClassMember(
- _findAsyncHelperClass("_IterationMarker"), "uncaughtError");
+ _findAsyncHelperClass("_IterationMarker"), "uncaughtError")
+ as FunctionEntity;
FunctionEntity get asyncStarHelper =>
_findAsyncHelperFunction("_asyncStarHelper");
@@ -657,7 +463,8 @@
_findAsyncHelperFunction("_streamOfController");
FunctionEntity get endOfIteration => _env.lookupLocalClassMember(
- _findAsyncHelperClass("_IterationMarker"), "endOfIteration");
+ _findAsyncHelperClass("_IterationMarker"), "endOfIteration")
+ as FunctionEntity;
ClassEntity get syncStarIterable =>
_findAsyncHelperClass("_SyncStarIterable");
@@ -672,95 +479,82 @@
ConstructorEntity get streamIteratorConstructor =>
_env.lookupConstructor(streamIterator, "");
- FunctionEntity get syncStarIterableFactory => _syncStarIterableFactory ??=
+ late final FunctionEntity syncStarIterableFactory =
_findAsyncHelperFunction('_makeSyncStarIterable');
- FunctionEntity get asyncAwaitCompleterFactory =>
- _asyncAwaitCompleterFactory ??=
- _findAsyncHelperFunction('_makeAsyncAwaitCompleter');
+ late final FunctionEntity asyncAwaitCompleterFactory =
+ _findAsyncHelperFunction('_makeAsyncAwaitCompleter');
- FunctionEntity get asyncStarStreamControllerFactory =>
- _asyncStarStreamControllerFactory ??=
- _findAsyncHelperFunction('_makeAsyncStarStreamController');
+ late final FunctionEntity asyncStarStreamControllerFactory =
+ _findAsyncHelperFunction('_makeAsyncStarStreamController');
// From dart:_interceptors
ClassEntity _findInterceptorsClass(String name) =>
- _findClass(interceptorsLibrary, name);
+ _findClass(interceptorsLibrary, name)!;
FunctionEntity _findInterceptorsFunction(String name) =>
- _findLibraryMember(interceptorsLibrary, name);
+ _findLibraryMember(interceptorsLibrary, name)!;
- ClassEntity get jsInterceptorClass =>
- _jsInterceptorClass ??= _findInterceptorsClass('Interceptor');
+ late final ClassEntity jsInterceptorClass =
+ _findInterceptorsClass('Interceptor');
- ClassEntity get jsStringClass =>
- _jsStringClass ??= _findInterceptorsClass('JSString');
+ late final ClassEntity jsStringClass = _findInterceptorsClass('JSString');
- ClassEntity get jsArrayClass =>
- _jsArrayClass ??= _findInterceptorsClass('JSArray');
+ late final ClassEntity jsArrayClass = _findInterceptorsClass('JSArray');
- ClassEntity get jsNumberClass =>
- _jsNumberClass ??= _findInterceptorsClass('JSNumber');
+ late final ClassEntity jsNumberClass = _findInterceptorsClass('JSNumber');
- ClassEntity get jsIntClass => _jsIntClass ??= _findInterceptorsClass('JSInt');
+ late final ClassEntity jsIntClass = _findInterceptorsClass('JSInt');
- ClassEntity get jsNumNotIntClass =>
- _jsNumNotIntClass ??= _findInterceptorsClass('JSNumNotInt');
+ late final ClassEntity jsNumNotIntClass =
+ _findInterceptorsClass('JSNumNotInt');
- ClassEntity get jsNullClass =>
- _jsNullClass ??= _findInterceptorsClass('JSNull');
+ late final ClassEntity jsNullClass = _findInterceptorsClass('JSNull');
- ClassEntity get jsBoolClass =>
- _jsBoolClass ??= _findInterceptorsClass('JSBool');
+ late final ClassEntity jsBoolClass = _findInterceptorsClass('JSBool');
- ClassEntity get jsPlainJavaScriptObjectClass =>
- _jsPlainJavaScriptObjectClass ??=
- _findInterceptorsClass('PlainJavaScriptObject');
+ late final ClassEntity jsPlainJavaScriptObjectClass =
+ _findInterceptorsClass('PlainJavaScriptObject');
- ClassEntity get jsUnknownJavaScriptObjectClass =>
- _jsUnknownJavaScriptObjectClass ??=
- _findInterceptorsClass('UnknownJavaScriptObject');
+ late final ClassEntity jsUnknownJavaScriptObjectClass =
+ _findInterceptorsClass('UnknownJavaScriptObject');
- ClassEntity get jsJavaScriptFunctionClass => _jsJavaScriptFunctionClass ??=
+ late final ClassEntity jsJavaScriptFunctionClass =
_findInterceptorsClass('JavaScriptFunction');
- @override // CommonElementsForDartTypes
InterfaceType get jsJavaScriptFunctionType =>
_getRawType(jsJavaScriptFunctionClass);
- ClassEntity get jsLegacyJavaScriptObjectClass =>
- _jsLegacyJavaScriptObjectClass ??=
- _findInterceptorsClass('LegacyJavaScriptObject');
+ late final ClassEntity jsLegacyJavaScriptObjectClass =
+ _findInterceptorsClass('LegacyJavaScriptObject');
- ClassEntity get jsJavaScriptObjectClass =>
- _jsJavaScriptObjectClass ??= _findInterceptorsClass('JavaScriptObject');
+ late final ClassEntity jsJavaScriptObjectClass =
+ _findInterceptorsClass('JavaScriptObject');
- ClassEntity get jsIndexableClass =>
- _jsIndexableClass ??= _findInterceptorsClass('JSIndexable');
+ late final ClassEntity jsIndexableClass =
+ _findInterceptorsClass('JSIndexable');
- ClassEntity get jsMutableIndexableClass =>
- _jsMutableIndexableClass ??= _findInterceptorsClass('JSMutableIndexable');
+ late final ClassEntity jsMutableIndexableClass =
+ _findInterceptorsClass('JSMutableIndexable');
- ClassEntity get jsMutableArrayClass =>
- _jsMutableArrayClass ??= _findInterceptorsClass('JSMutableArray');
+ late final ClassEntity jsMutableArrayClass =
+ _findInterceptorsClass('JSMutableArray');
- ClassEntity get jsFixedArrayClass =>
- _jsFixedArrayClass ??= _findInterceptorsClass('JSFixedArray');
+ late final ClassEntity jsFixedArrayClass =
+ _findInterceptorsClass('JSFixedArray');
- ClassEntity get jsExtendableArrayClass =>
- _jsExtendableArrayClass ??= _findInterceptorsClass('JSExtendableArray');
+ late final ClassEntity jsExtendableArrayClass =
+ _findInterceptorsClass('JSExtendableArray');
- ClassEntity get jsUnmodifiableArrayClass => _jsUnmodifiableArrayClass ??=
+ late final ClassEntity jsUnmodifiableArrayClass =
_findInterceptorsClass('JSUnmodifiableArray');
- ClassEntity get jsPositiveIntClass =>
- _jsPositiveIntClass ??= _findInterceptorsClass('JSPositiveInt');
+ late final ClassEntity jsPositiveIntClass =
+ _findInterceptorsClass('JSPositiveInt');
- ClassEntity get jsUInt32Class =>
- _jsUInt32Class ??= _findInterceptorsClass('JSUInt32');
+ late final ClassEntity jsUInt32Class = _findInterceptorsClass('JSUInt32');
- ClassEntity get jsUInt31Class =>
- _jsUInt31Class ??= _findInterceptorsClass('JSUInt31');
+ late final ClassEntity jsUInt31Class = _findInterceptorsClass('JSUInt31');
/// Returns `true` member is the 'findIndexForNativeSubclassType' method
/// declared in `dart:_interceptors`.
@@ -770,112 +564,95 @@
member.library == interceptorsLibrary;
}
- FunctionEntity get getNativeInterceptorMethod =>
- _getNativeInterceptorMethod ??=
- _findInterceptorsFunction('getNativeInterceptor');
+ late final FunctionEntity getNativeInterceptorMethod =
+ _findInterceptorsFunction('getNativeInterceptor');
- ConstructorEntity get jsArrayTypedConstructor =>
- _jsArrayTypedConstructor ??= _findConstructor(jsArrayClass, 'typed');
+ late final ConstructorEntity jsArrayTypedConstructor =
+ _findConstructor(jsArrayClass, 'typed');
// From dart:_js_helper
// TODO(johnniwinther): Avoid the need for this (from [CheckedModeHelper]).
FunctionEntity findHelperFunction(String name) => _findHelperFunction(name);
FunctionEntity _findHelperFunction(String name) =>
- _findLibraryMember(jsHelperLibrary, name);
+ _findLibraryMember(jsHelperLibrary, name)!;
ClassEntity _findHelperClass(String name) =>
- _findClass(jsHelperLibrary, name);
+ _findClass(jsHelperLibrary, name)!;
FunctionEntity _findLateHelperFunction(String name) =>
- _findLibraryMember(lateHelperLibrary, name);
+ _findLibraryMember(lateHelperLibrary, name)!;
- ClassEntity get closureClass => _closureClass ??= _findHelperClass('Closure');
+ late final ClassEntity closureClass = _findHelperClass('Closure');
- ClassEntity get closureClass0Args =>
- _closureClass0Args ??= _findHelperClass('Closure0Args');
+ late final ClassEntity closureClass0Args = _findHelperClass('Closure0Args');
- ClassEntity get closureClass2Args =>
- _closureClass2Args ??= _findHelperClass('Closure2Args');
+ late final ClassEntity closureClass2Args = _findHelperClass('Closure2Args');
- ClassEntity get boundClosureClass =>
- _boundClosureClass ??= _findHelperClass('BoundClosure');
+ late final ClassEntity boundClosureClass = _findHelperClass('BoundClosure');
- ClassEntity get typeLiteralClass =>
- _typeLiteralClass ??= _findRtiClass('_Type');
+ late final ClassEntity typeLiteralClass = _findRtiClass('_Type');
- ClassEntity get constMapLiteralClass =>
- _constMapLiteralClass ??= _findHelperClass('ConstantMap');
+ late final ClassEntity constMapLiteralClass = _findHelperClass('ConstantMap');
// TODO(fishythefish): Implement a `ConstantSet` class and update the backend
// impacts + constant emitter accordingly.
- ClassEntity get constSetLiteralClass =>
- _constSetLiteralClass ??= unmodifiableSetClass;
+ late final ClassEntity constSetLiteralClass = unmodifiableSetClass;
- ClassEntity get jsInvocationMirrorClass =>
- _jsInvocationMirrorClass ??= _findHelperClass('JSInvocationMirror');
+ late final ClassEntity jsInvocationMirrorClass =
+ _findHelperClass('JSInvocationMirror');
- ClassEntity get requiredSentinelClass =>
- _requiredSentinelClass ??= _findHelperClass('_Required');
+ late final ClassEntity requiredSentinelClass = _findHelperClass('_Required');
InterfaceType get requiredSentinelType => _getRawType(requiredSentinelClass);
- MemberEntity get invocationTypeArgumentGetter =>
- _invocationTypeArgumentGetter ??=
- _findClassMember(jsInvocationMirrorClass, 'typeArguments');
+ late final MemberEntity invocationTypeArgumentGetter =
+ _findClassMember(jsInvocationMirrorClass, 'typeArguments');
/// Interface used to determine if an object has the JavaScript
/// indexing behavior. The interface is only visible to specific libraries.
- ClassEntity get jsIndexingBehaviorInterface =>
- _jsIndexingBehaviorInterface ??=
- _findHelperClass('JavaScriptIndexingBehavior');
+ late final ClassEntity jsIndexingBehaviorInterface =
+ _findHelperClass('JavaScriptIndexingBehavior');
- ClassEntity get stackTraceHelperClass => _findHelperClass('_StackTrace');
+ late final ClassEntity stackTraceHelperClass =
+ _findHelperClass('_StackTrace');
- ClassEntity get constantMapClass =>
+ late final ClassEntity constantMapClass =
_findHelperClass(constant_system.JavaScriptMapConstant.DART_CLASS);
- ClassEntity get constantStringMapClass =>
+ late final ClassEntity constantStringMapClass =
_findHelperClass(constant_system.JavaScriptMapConstant.DART_STRING_CLASS);
- ClassEntity get generalConstantMapClass => _findHelperClass(
+ late final ClassEntity generalConstantMapClass = _findHelperClass(
constant_system.JavaScriptMapConstant.DART_GENERAL_CLASS);
- ClassEntity get annotationCreatesClass => _findHelperClass('Creates');
+ late final ClassEntity annotationCreatesClass = _findHelperClass('Creates');
- ClassEntity get annotationReturnsClass => _findHelperClass('Returns');
+ late final ClassEntity annotationReturnsClass = _findHelperClass('Returns');
- ClassEntity get annotationJSNameClass => _findHelperClass('JSName');
+ late final ClassEntity annotationJSNameClass = _findHelperClass('JSName');
/// The class for native annotations defined in dart:_js_helper.
- ClassEntity get nativeAnnotationClass =>
- _nativeAnnotationClass ??= _findHelperClass('Native');
+ late final ClassEntity nativeAnnotationClass = _findHelperClass('Native');
- FunctionEntity get assertTest =>
- _assertTest ??= _findHelperFunction('assertTest');
+ late final assertTest = _findHelperFunction('assertTest');
- FunctionEntity get assertThrow =>
- _assertThrow ??= _findHelperFunction('assertThrow');
+ late final assertThrow = _findHelperFunction('assertThrow');
- FunctionEntity get assertHelper =>
- _assertHelper ??= _findHelperFunction('assertHelper');
+ late final assertHelper = _findHelperFunction('assertHelper');
- FunctionEntity get assertUnreachableMethod =>
- _assertUnreachableMethod ??= _findHelperFunction('assertUnreachable');
+ late final assertUnreachableMethod = _findHelperFunction('assertUnreachable');
/// Holds the method "getIsolateAffinityTag" when dart:_js_helper has been
/// loaded.
- FunctionEntity get getIsolateAffinityTagMarker =>
- _getIsolateAffinityTagMarker ??=
- _findHelperFunction('getIsolateAffinityTag');
+ late final getIsolateAffinityTagMarker =
+ _findHelperFunction('getIsolateAffinityTag');
/// Holds the method "requiresPreamble" in _js_helper.
- FunctionEntity get requiresPreambleMarker =>
- _requiresPreambleMarker ??= _findHelperFunction('requiresPreamble');
+ late final requiresPreambleMarker = _findHelperFunction('requiresPreamble');
/// Holds the method "_rawStartupMetrics" in _js_helper.
- FunctionEntity get rawStartupMetrics =>
- _rawStartupMetrics ??= _findHelperFunction('rawStartupMetrics');
+ late final rawStartupMetrics = _findHelperFunction('rawStartupMetrics');
FunctionEntity get loadDeferredLibrary =>
_findHelperFunction("loadDeferredLibrary");
@@ -913,9 +690,8 @@
member.library == jsHelperLibrary;
}
- FunctionEntity get checkConcurrentModificationError =>
- _cachedCheckConcurrentModificationError ??=
- _findHelperFunction('checkConcurrentModificationError');
+ late final FunctionEntity checkConcurrentModificationError =
+ _findHelperFunction('checkConcurrentModificationError');
FunctionEntity get throwConcurrentModificationError =>
_findHelperFunction('throwConcurrentModificationError');
@@ -999,62 +775,57 @@
// From dart:_rti
- ClassEntity _findRtiClass(String name) => _findClass(rtiLibrary, name);
+ ClassEntity _findRtiClass(String name) => _findClass(rtiLibrary, name)!;
FunctionEntity _findRtiFunction(String name) =>
- _findLibraryMember(rtiLibrary, name);
+ _findLibraryMember(rtiLibrary, name)!;
- FunctionEntity get setArrayType =>
- _setArrayType ??= _findRtiFunction('_setArrayType');
+ late final FunctionEntity setArrayType = _findRtiFunction('_setArrayType');
- FunctionEntity get findType => _findType ??= _findRtiFunction('findType');
+ late final FunctionEntity findType = _findRtiFunction('findType');
- FunctionEntity get instanceType =>
- _instanceType ??= _findRtiFunction('instanceType');
+ late final FunctionEntity instanceType = _findRtiFunction('instanceType');
- FunctionEntity get arrayInstanceType =>
- _arrayInstanceType ??= _findRtiFunction('_arrayInstanceType');
+ late final FunctionEntity arrayInstanceType =
+ _findRtiFunction('_arrayInstanceType');
- FunctionEntity get simpleInstanceType =>
- _simpleInstanceType ??= _findRtiFunction('_instanceType');
+ late final FunctionEntity simpleInstanceType =
+ _findRtiFunction('_instanceType');
- FunctionEntity get typeLiteralMaker =>
- _typeLiteralMaker ??= _findRtiFunction('typeLiteral');
+ late final FunctionEntity typeLiteralMaker = _findRtiFunction('typeLiteral');
- FunctionEntity get checkTypeBound =>
- _checkTypeBound ??= _findRtiFunction('checkTypeBound');
+ late final FunctionEntity checkTypeBound = _findRtiFunction('checkTypeBound');
- ClassEntity get _rtiImplClass => _findClass(rtiLibrary, 'Rti');
+ ClassEntity get _rtiImplClass => _findClass(rtiLibrary, 'Rti')!;
- ClassEntity get _rtiUniverseClass => _findClass(rtiLibrary, '_Universe');
+ ClassEntity get _rtiUniverseClass => _findClass(rtiLibrary, '_Universe')!;
FieldEntity _findRtiClassField(String name) =>
_findClassMember(_rtiImplClass, name);
- FieldEntity get rtiAsField => _rtiAsField ??= _findRtiClassField('_as');
+ late final FieldEntity rtiAsField = _findRtiClassField('_as');
- FieldEntity get rtiIsField => _rtiIsField ??= _findRtiClassField('_is');
+ late final FieldEntity rtiIsField = _findRtiClassField('_is');
- FieldEntity get rtiRestField => _rtiRestField ??= _findRtiClassField('_rest');
+ late final FieldEntity rtiRestField = _findRtiClassField('_rest');
- FieldEntity get rtiPrecomputed1Field =>
- _rtiPrecomputed1Field ??= _findRtiClassField('_precomputed1');
+ late final FieldEntity rtiPrecomputed1Field =
+ _findRtiClassField('_precomputed1');
- FunctionEntity get rtiEvalMethod =>
- _rtiEvalMethod ??= _findClassMember(_rtiImplClass, '_eval');
+ late final FunctionEntity rtiEvalMethod =
+ _findClassMember(_rtiImplClass, '_eval');
- FunctionEntity get rtiBindMethod =>
- _rtiBindMethod ??= _findClassMember(_rtiImplClass, '_bind');
+ late final FunctionEntity rtiBindMethod =
+ _findClassMember(_rtiImplClass, '_bind');
- FunctionEntity get rtiAddRulesMethod =>
- _rtiAddRulesMethod ??= _findClassMember(_rtiUniverseClass, 'addRules');
+ late final FunctionEntity rtiAddRulesMethod =
+ _findClassMember(_rtiUniverseClass, 'addRules');
- FunctionEntity get rtiAddErasedTypesMethod => _rtiAddErasedTypesMethod ??=
+ late final FunctionEntity rtiAddErasedTypesMethod =
_findClassMember(_rtiUniverseClass, 'addErasedTypes');
- FunctionEntity get rtiAddTypeParameterVariancesMethod =>
- _rtiAddTypeParameterVariancesMethod ??=
- _findClassMember(_rtiUniverseClass, 'addTypeParameterVariances');
+ late final FunctionEntity rtiAddTypeParameterVariancesMethod =
+ _findClassMember(_rtiUniverseClass, 'addTypeParameterVariances');
FunctionEntity get installSpecializedIsTest =>
_findRtiFunction('_installSpecializedIsTest');
@@ -1062,27 +833,21 @@
FunctionEntity get installSpecializedAsCheck =>
_findRtiFunction('_installSpecializedAsCheck');
- FunctionEntity get generalIsTestImplementation =>
- _generalIsTestImplementation ??=
- _findRtiFunction('_generalIsTestImplementation');
+ late final FunctionEntity generalIsTestImplementation =
+ _findRtiFunction('_generalIsTestImplementation');
- FunctionEntity get generalNullableIsTestImplementation =>
- _generalNullableIsTestImplementation ??=
- _findRtiFunction('_generalNullableIsTestImplementation');
+ late final FunctionEntity generalNullableIsTestImplementation =
+ _findRtiFunction('_generalNullableIsTestImplementation');
- FunctionEntity get generalAsCheckImplementation =>
- _generalAsCheckImplementation ??=
- _findRtiFunction('_generalAsCheckImplementation');
+ late final FunctionEntity generalAsCheckImplementation =
+ _findRtiFunction('_generalAsCheckImplementation');
- FunctionEntity get generalNullableAsCheckImplementation =>
- _generalNullableAsCheckImplementation ??=
- _findRtiFunction('_generalNullableAsCheckImplementation');
+ late final FunctionEntity generalNullableAsCheckImplementation =
+ _findRtiFunction('_generalNullableAsCheckImplementation');
- FunctionEntity get specializedIsObject =>
- _specializedIsObject ??= _findRtiFunction('_isObject');
+ late final FunctionEntity specializedIsObject = _findRtiFunction('_isObject');
- FunctionEntity get specializedAsObject =>
- _specializedAsObject ??= _findRtiFunction('_asObject');
+ late final FunctionEntity specializedAsObject = _findRtiFunction('_asObject');
FunctionEntity get specializedIsTop => _findRtiFunction('_isTop');
@@ -1138,20 +903,20 @@
// From dart:_internal
- ClassEntity get symbolImplementationClass =>
- _symbolImplementationClass ??= _findClass(internalLibrary, 'Symbol');
+ late final ClassEntity symbolImplementationClass =
+ _findClass(internalLibrary, 'Symbol')!;
/// Used to annotate items that have the keyword "native".
- ClassEntity get externalNameClass =>
- _externalNameClass ??= _findClass(internalLibrary, 'ExternalName');
+ late final ClassEntity externalNameClass =
+ _findClass(internalLibrary, 'ExternalName')!;
InterfaceType get externalNameType => _getRawType(externalNameClass);
// From dart:_js_embedded_names
- ClassEntity get jsGetNameEnum => _jsGetNameEnum ??= _findClass(
+ late final ClassEntity jsGetNameEnum = _findClass(
_env.lookupLibrary(Uris.dart__js_embedded_names, required: true),
- 'JsGetName');
+ 'JsGetName')!;
/// Returns `true` if [member] is a "foreign helper", that is, a member whose
/// semantics is defined synthetically and not through Dart code.
@@ -1222,11 +987,11 @@
}
// From package:js
- FunctionEntity get jsAllowInterop1 => _jsAllowInterop1 ??=
+ late final FunctionEntity? jsAllowInterop1 =
_findLibraryMember(dartJsLibrary, 'allowInterop', required: false);
// From dart:_js_annotations;
- FunctionEntity get jsAllowInterop2 => _jsAllowInterop2 ??= _findLibraryMember(
+ late final FunctionEntity? jsAllowInterop2 = _findLibraryMember(
dartJsAnnotationsLibrary, 'allowInterop',
required: false);
@@ -1245,31 +1010,23 @@
}
class KCommonElements extends CommonElements {
- ClassEntity _jsAnnotationClass1;
- ClassEntity _jsAnonymousClass1;
- ClassEntity _jsAnnotationClass2;
- ClassEntity _jsAnonymousClass2;
- ClassEntity _pragmaClass;
- FieldEntity _pragmaClassNameField;
- FieldEntity _pragmaClassOptionsField;
-
KCommonElements(DartTypes dartTypes, ElementEnvironment env)
: super(dartTypes, env);
// From package:js
- ClassEntity get jsAnnotationClass1 => _jsAnnotationClass1 ??=
+ late final ClassEntity? jsAnnotationClass1 =
_findClass(packageJsLibrary, 'JS', required: false);
- ClassEntity get jsAnonymousClass1 => _jsAnonymousClass1 ??=
+ late final ClassEntity? jsAnonymousClass1 =
_findClass(packageJsLibrary, '_Anonymous', required: false);
// From dart:_js_annotations
- ClassEntity get jsAnnotationClass2 => _jsAnnotationClass2 ??=
+ late final ClassEntity? jsAnnotationClass2 =
_findClass(dartJsAnnotationsLibrary, 'JS', required: false);
- ClassEntity get jsAnonymousClass2 => _jsAnonymousClass2 ??=
+ late final ClassEntity? jsAnonymousClass2 =
_findClass(dartJsAnnotationsLibrary, '_Anonymous', required: false);
/// Returns `true` if [cls] is a @JS() annotation.
@@ -1286,26 +1043,17 @@
return cls == jsAnonymousClass1 || cls == jsAnonymousClass2;
}
- ClassEntity get pragmaClass =>
- _pragmaClass ??= _findClass(coreLibrary, 'pragma');
+ late final ClassEntity pragmaClass = _findClass(coreLibrary, 'pragma')!;
- FieldEntity get pragmaClassNameField =>
- _pragmaClassNameField ??= _findClassMember(pragmaClass, 'name');
+ late final FieldEntity pragmaClassNameField =
+ _findClassMember(pragmaClass, 'name');
- FieldEntity get pragmaClassOptionsField =>
- _pragmaClassOptionsField ??= _findClassMember(pragmaClass, 'options');
+ late final FieldEntity pragmaClassOptionsField =
+ _findClassMember(pragmaClass, 'options');
}
class JCommonElements extends CommonElements {
- FunctionEntity _jsArrayRemoveLast;
- FunctionEntity _jsArrayAdd;
- FunctionEntity _jsStringSplit;
- FunctionEntity _jsStringToString;
- FunctionEntity _jsStringOperatorAdd;
- ClassEntity _jsConstClass;
- ClassEntity _typedArrayOfIntClass;
- ClassEntity _typedArrayOfDoubleClass;
- ClassEntity _jsBuiltinEnum;
+ FunctionEntity? _jsStringSplit;
JCommonElements(DartTypes dartTypes, ElementEnvironment env)
: super(dartTypes, env);
@@ -1336,7 +1084,7 @@
bool isDefaultEqualityImplementation(MemberEntity element) {
assert(element.name == '==');
- ClassEntity classElement = element.enclosingClass;
+ ClassEntity? classElement = element.enclosingClass;
return classElement == objectClass ||
classElement == jsInterceptorClass ||
classElement == jsNullClass;
@@ -1347,11 +1095,10 @@
return selector.name == 'length' && (selector.isGetter || selector.isCall);
}
- FunctionEntity get jsArrayRemoveLast =>
- _jsArrayRemoveLast ??= _findClassMember(jsArrayClass, 'removeLast');
+ late final FunctionEntity jsArrayRemoveLast =
+ _findClassMember(jsArrayClass, 'removeLast');
- FunctionEntity get jsArrayAdd =>
- _jsArrayAdd ??= _findClassMember(jsArrayClass, 'add');
+ late final FunctionEntity jsArrayAdd = _findClassMember(jsArrayClass, 'add');
bool _isJsStringClass(ClassEntity cls) {
return cls.name == 'JSString' && cls.library == interceptorsLibrary;
@@ -1360,23 +1107,23 @@
bool isJsStringSplit(MemberEntity member) {
return member.name == 'split' &&
member.isInstanceMember &&
- _isJsStringClass(member.enclosingClass);
+ _isJsStringClass(member.enclosingClass!);
}
/// Returns `true` if [selector] applies to `JSString.split` on [receiver]
/// in the given [world].
///
/// Returns `false` if `JSString.split` is not available.
- bool appliesToJsStringSplit(Selector selector, AbstractValue receiver,
+ bool appliesToJsStringSplit(Selector selector, AbstractValue? receiver,
AbstractValueDomain abstractValueDomain) {
if (_jsStringSplit == null) {
- ClassEntity cls =
+ ClassEntity? cls =
_findClass(interceptorsLibrary, 'JSString', required: false);
if (cls == null) return false;
_jsStringSplit = _findClassMember(cls, 'split', required: false);
if (_jsStringSplit == null) return false;
}
- return selector.applies(_jsStringSplit) &&
+ return selector.applies(_jsStringSplit!) &&
(receiver == null ||
abstractValueDomain
.isTargetingMember(receiver, jsStringSplit, selector.memberName)
@@ -1386,14 +1133,13 @@
FunctionEntity get jsStringSplit =>
_jsStringSplit ??= _findClassMember(jsStringClass, 'split');
- FunctionEntity get jsStringToString =>
- _jsStringToString ??= _findClassMember(jsStringClass, 'toString');
+ late final FunctionEntity jsStringToString =
+ _findClassMember(jsStringClass, 'toString');
- FunctionEntity get jsStringOperatorAdd =>
- _jsStringOperatorAdd ??= _findClassMember(jsStringClass, '+');
+ late final FunctionEntity jsStringOperatorAdd =
+ _findClassMember(jsStringClass, '+');
- ClassEntity get jsConstClass =>
- _jsConstClass ??= _findClass(foreignLibrary, 'JS_CONST');
+ late final ClassEntity jsConstClass = _findClass(foreignLibrary, 'JS_CONST')!;
/// Return `true` if [member] is the 'checkInt' function defined in
/// dart:_js_helpers.
@@ -1423,25 +1169,24 @@
}
bool isInstantiationClass(ClassEntity cls) {
- return cls.library == _jsHelperLibrary &&
+ return cls.library == jsHelperLibrary &&
cls.name != 'Instantiation' &&
cls.name.startsWith('Instantiation');
}
// From dart:_native_typed_data
- ClassEntity get typedArrayOfIntClass => _typedArrayOfIntClass ??= _findClass(
+ late final ClassEntity? typedArrayOfIntClass = _findClass(
_env.lookupLibrary(Uris.dart__native_typed_data, required: true),
'NativeTypedArrayOfInt');
- ClassEntity get typedArrayOfDoubleClass =>
- _typedArrayOfDoubleClass ??= _findClass(
- _env.lookupLibrary(Uris.dart__native_typed_data, required: true),
- 'NativeTypedArrayOfDouble');
+ late final ClassEntity typedArrayOfDoubleClass = _findClass(
+ _env.lookupLibrary(Uris.dart__native_typed_data, required: true),
+ 'NativeTypedArrayOfDouble')!;
- ClassEntity get jsBuiltinEnum => _jsBuiltinEnum ??= _findClass(
+ late final ClassEntity jsBuiltinEnum = _findClass(
_env.lookupLibrary(Uris.dart__js_embedded_names, required: true),
- 'JsBuiltin');
+ 'JsBuiltin')!;
bool isForeign(MemberEntity element) => element.library == foreignLibrary;
@@ -1450,7 +1195,7 @@
bool operatorEqHandlesNullArgument(FunctionEntity function) {
assert(function.name == '==',
failedAt(function, "Unexpected function $function."));
- ClassEntity cls = function.enclosingClass;
+ ClassEntity? cls = function.enclosingClass;
return cls == objectClass ||
cls == jsInterceptorClass ||
cls == jsNullClass;
@@ -1482,14 +1227,14 @@
/// Lookup the library with the canonical [uri], fail if the library is
/// missing and [required];
- LibraryEntity lookupLibrary(Uri uri, {bool required = false});
+ LibraryEntity? lookupLibrary(Uri uri, {bool required = false});
/// Calls [f] for every class declared in [library].
void forEachClass(LibraryEntity library, void f(ClassEntity cls));
/// Lookup the class [name] in [library], fail if the class is missing and
/// [required].
- ClassEntity lookupClass(LibraryEntity library, String name,
+ ClassEntity? lookupClass(LibraryEntity library, String name,
{bool required = false});
/// Calls [f] for every top level member in [library].
@@ -1497,26 +1242,27 @@
/// Lookup the member [name] in [library], fail if the class is missing and
/// [required].
- MemberEntity lookupLibraryMember(LibraryEntity library, String name,
+ MemberEntity? lookupLibraryMember(LibraryEntity library, String name,
{bool setter = false, bool required = false});
/// Lookup the member [name] in [cls], fail if the class is missing and
/// [required].
- MemberEntity lookupLocalClassMember(ClassEntity cls, String name,
+ MemberEntity? lookupLocalClassMember(ClassEntity cls, String name,
{bool setter = false, bool required = false});
/// Lookup the member [name] in [cls] and its superclasses.
///
/// Return `null` if the member is not found in the class or any superclass.
- MemberEntity lookupClassMember(ClassEntity cls, String name,
+ MemberEntity? lookupClassMember(ClassEntity cls, String name,
{bool setter = false}) {
- while (true) {
- final entity = lookupLocalClassMember(cls, name, setter: setter);
+ ClassEntity? clsLocal = cls;
+ while (clsLocal != null) {
+ final entity = lookupLocalClassMember(clsLocal, name, setter: setter);
if (entity != null) return entity;
- cls = getSuperClass(cls);
- if (cls == null) return null;
+ clsLocal = getSuperClass(clsLocal);
}
+ return null;
}
/// Lookup the constructor [name] in [cls], fail if the class is missing and
@@ -1555,7 +1301,7 @@
/// typically named `S+M` and `getSuperClass(S+M)` is `S`, whereas
/// the result of `getSuperClass(C, skipUnnamedMixinApplications: false)` is
/// `S`.
- ClassEntity getSuperClass(ClassEntity cls,
+ ClassEntity? getSuperClass(ClassEntity cls,
{bool skipUnnamedMixinApplications = false});
/// Calls [f] for each supertype of [cls].
@@ -1580,7 +1326,7 @@
/// Returns the 'raw type' of [cls]. That is, the instantiation of [cls]
/// where all types arguments are `dynamic`.
- InterfaceType /*!*/ getRawType(ClassEntity /*!*/ cls);
+ InterfaceType getRawType(ClassEntity cls);
/// Returns the 'JS-interop type' of [cls]; that is, the instantiation of
/// [cls] where all type arguments are 'any'.
@@ -1591,7 +1337,7 @@
InterfaceType getThisType(ClassEntity cls);
/// Returns the instantiation of [cls] to bounds.
- InterfaceType /*!*/ getClassInstantiationToBounds(ClassEntity cls);
+ InterfaceType getClassInstantiationToBounds(ClassEntity cls);
/// Returns `true` if [cls] is generic.
bool isGenericClass(ClassEntity cls);
@@ -1712,6 +1458,6 @@
void f(DartType type, String name, ConstantValue defaultValue));
/// Calls [f] for each parameter - given as a [Local] - of [function].
- void forEachParameterAsLocal(GlobalLocalsMap globalLocalsMap,
+ void forEachParameterAsLocal(covariant GlobalLocalsMap globalLocalsMap,
FunctionEntity function, void f(Local parameter));
}
diff --git a/pkg/compiler/lib/src/constants/common_elements_for_constants.dart b/pkg/compiler/lib/src/constants/common_elements_for_constants.dart
deleted file mode 100644
index 7aee2af..0000000
--- a/pkg/compiler/lib/src/constants/common_elements_for_constants.dart
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2022, 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.
-
-import '../elements/entities.dart';
-import '../elements/types.dart';
-
-/// This is a facade interface for the members of CommonElements that are
-/// required by 'constants/value.dart'.
-// TODO(48820): When CommonElements is migrated, remove this facade.
-abstract class CommonElements {
- DartType get boolType;
- DartType get doubleType;
- DartType get dynamicType;
- DartType get intType;
- DartType get nullType;
- DartType get stringType;
-
- DartTypes get dartTypes;
-
- InterfaceType getConstantListTypeFor(InterfaceType sourceType);
- InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
- {bool onlyStringKeys = false});
- InterfaceType getConstantSetTypeFor(InterfaceType sourceType);
- InterfaceType listType([DartType? elementType]);
- InterfaceType mapType([DartType? keyType, DartType? valueType]);
- InterfaceType get symbolImplementationType;
- InterfaceType get typeLiteralType;
-
- FieldEntity get symbolField;
-}
diff --git a/pkg/compiler/lib/src/constants/constant_system.dart b/pkg/compiler/lib/src/constants/constant_system.dart
index 81daa78..3a8841c 100644
--- a/pkg/compiler/lib/src/constants/constant_system.dart
+++ b/pkg/compiler/lib/src/constants/constant_system.dart
@@ -6,8 +6,7 @@
/// compiled to JavaScript.
library dart2js.constant_system;
-//import '../common/elements.dart' show CommonElements;
-import 'common_elements_for_constants.dart';
+import '../common/elements.dart' show CommonElements;
import '../elements/entities.dart';
import '../elements/types.dart';
import 'values.dart';
diff --git a/pkg/compiler/lib/src/constants/values.dart b/pkg/compiler/lib/src/constants/values.dart
index ccabdeb..b12d2da 100644
--- a/pkg/compiler/lib/src/constants/values.dart
+++ b/pkg/compiler/lib/src/constants/values.dart
@@ -5,16 +5,13 @@
library dart2js.constants.values;
import '../common.dart';
+import '../common/elements.dart' show CommonElements;
import '../elements/entities.dart';
import '../elements/types.dart';
import '../deferred_load/output_unit_migrated.dart' show OutputUnit;
import '../js/js.dart' as js;
import '../util/util.dart';
-import 'common_elements_for_constants.dart';
-// TODO(48820): When CommonElements is migrated, replace this import with
-// import '../common/elements.dart' show CommonElements;
-
enum ConstantValueKind {
FUNCTION,
NULL,
diff --git a/pkg/compiler/lib/src/elements/types.dart b/pkg/compiler/lib/src/elements/types.dart
index 6f217cd..47e94c1 100644
--- a/pkg/compiler/lib/src/elements/types.dart
+++ b/pkg/compiler/lib/src/elements/types.dart
@@ -2,6 +2,7 @@
// 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.
+import '../common/elements.dart' show CommonElements;
import '../common/names.dart';
import '../options.dart';
import '../serialization/serialization_interfaces.dart';
@@ -1696,22 +1697,10 @@
}
}
-/// The subset of CommonElements methods needed for DartTypes.
-// TODO(48820): Replace with CommonElements once that is migrated.
-abstract class CommonElementsForDartTypes {
- InterfaceType get nullType;
- InterfaceType get intType;
- InterfaceType get doubleType;
- InterfaceType get functionType;
- InterfaceType get objectType;
- InterfaceType get jsJavaScriptFunctionType;
- InterfaceType futureType(DartType elementType);
-}
-
/// Basic interface for the Dart type system.
abstract class DartTypes {
/// The types defined in 'dart:core'.
- CommonElementsForDartTypes get commonElements;
+ CommonElements get commonElements;
bool get useLegacySubtyping;
diff --git a/pkg/compiler/lib/src/js_backend/native_data.dart b/pkg/compiler/lib/src/js_backend/native_data.dart
index f4f71f9..edc6de8 100644
--- a/pkg/compiler/lib/src/js_backend/native_data.dart
+++ b/pkg/compiler/lib/src/js_backend/native_data.dart
@@ -18,6 +18,8 @@
import '../serialization/serialization.dart';
import '../util/util.dart';
+import 'native_data_interfaces.dart' as interfaces;
+
class NativeBasicDataBuilder {
bool _closed = false;
@@ -133,7 +135,7 @@
/// Basic information for native classes and js-interop libraries and classes.
///
/// This information is computed during loading using [NativeBasicDataBuilder].
-class NativeBasicData {
+class NativeBasicData implements interfaces.NativeBasicData {
/// Tag used for identifying serialized [NativeBasicData] objects in a
/// debugging data stream.
static const String tag = 'native-basic-data';
@@ -261,6 +263,7 @@
/// A class is marked as native either through the `@Native(...)` annotation
/// allowed for internal libraries or via the typed JavaScriptInterop
/// mechanism allowed for user libraries.
+ @override
bool isNativeClass(ClassEntity element) {
if (isJsInteropClass(element)) return true;
return _nativeClassTagInfo.containsKey(element);
@@ -286,6 +289,7 @@
}
/// Returns `true` if [element] is a JsInterop class.
+ @override
bool isJsInteropClass(ClassEntity element) {
return _jsInteropClasses.containsKey(element);
}
diff --git a/pkg/compiler/lib/src/js_backend/native_data_interfaces.dart b/pkg/compiler/lib/src/js_backend/native_data_interfaces.dart
new file mode 100644
index 0000000..405d858
--- /dev/null
+++ b/pkg/compiler/lib/src/js_backend/native_data_interfaces.dart
@@ -0,0 +1,14 @@
+// Copyright (c) 2022, 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.
+
+import 'package:compiler/src/elements/entities.dart';
+
+/// This is a facade interface for the members of NativeBasicData that are
+/// required by other migrated classes.
+// TODO(48820): When NativeBasicData is migrated, remove this facade.
+abstract class NativeBasicData {
+ bool isJsInteropClass(ClassEntity element);
+
+ bool isNativeClass(ClassEntity element);
+}
diff --git a/pkg/compiler/lib/src/js_model/locals.dart b/pkg/compiler/lib/src/js_model/locals.dart
index b6d3d6b..f76178a 100644
--- a/pkg/compiler/lib/src/js_model/locals.dart
+++ b/pkg/compiler/lib/src/js_model/locals.dart
@@ -18,8 +18,9 @@
import 'element_map.dart';
import 'elements.dart' show JGeneratorBody;
+import 'locals_interfaces.dart' as interfaces;
-class GlobalLocalsMap {
+class GlobalLocalsMap implements interfaces.GlobalLocalsMap {
/// Tag used for identifying serialized [GlobalLocalsMap] objects in a
/// debugging data stream.
static const String tag = 'global-locals-map';
diff --git a/pkg/compiler/lib/src/js_model/locals_interfaces.dart b/pkg/compiler/lib/src/js_model/locals_interfaces.dart
new file mode 100644
index 0000000..7c4267c
--- /dev/null
+++ b/pkg/compiler/lib/src/js_model/locals_interfaces.dart
@@ -0,0 +1,8 @@
+// Copyright (c) 2022, 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.
+
+/// This is a facade interface for the members of GlobalLocalsMap that are
+/// required by other migrated classes.
+// TODO(48820): When GlobalLocalsMap is migrated, remove this facade.
+abstract class GlobalLocalsMap {}
diff --git a/pkg/compiler/lib/src/serialization/helpers.dart b/pkg/compiler/lib/src/serialization/helpers.dart
index 46791ba..2e395b7 100644
--- a/pkg/compiler/lib/src/serialization/helpers.dart
+++ b/pkg/compiler/lib/src/serialization/helpers.dart
@@ -133,8 +133,6 @@
_sink.writeBool(parameter.isRequired);
_sink._writeDartTypeNode(parameter.type, functionTypeVariables);
}
- _sink._writeDartTypeNode(node.typedefType, functionTypeVariables,
- allowNull: true);
_sink.end(functionTypeNodeTag);
}
diff --git a/pkg/compiler/lib/src/serialization/source.dart b/pkg/compiler/lib/src/serialization/source.dart
index efe6512..b09e780 100644
--- a/pkg/compiler/lib/src/serialization/source.dart
+++ b/pkg/compiler/lib/src/serialization/source.dart
@@ -767,13 +767,11 @@
namedParameters[index] =
ir.NamedType(name, type, isRequired: isRequired);
}
- ir.TypedefType typedefType = _readDartTypeNode(functionTypeVariables);
end(functionTypeNodeTag);
return ir.FunctionType(positionalParameters, returnType, nullability,
namedParameters: namedParameters,
typeParameters: typeParameters,
- requiredParameterCount: requiredParameterCount,
- typedefType: typedefType);
+ requiredParameterCount: requiredParameterCount);
case DartTypeNodeKind.interfaceType:
ir.Class cls = readClassNode();
diff --git a/pkg/front_end/lib/src/fasta/builder/builtin_type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/builtin_type_declaration_builder.dart
index ce5ed5b..02c6b57 100644
--- a/pkg/front_end/lib/src/fasta/builder/builtin_type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/builtin_type_declaration_builder.dart
@@ -25,14 +25,26 @@
super(null, 0, name, compilationUnit, charOffset);
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type.withDeclaredNullability(nullabilityBuilder.build(library));
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type.withDeclaredNullability(nullability);
}
diff --git a/pkg/front_end/lib/src/fasta/builder/class_builder.dart b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
index 4ecde96..8f483a0 100644
--- a/pkg/front_end/lib/src/fasta/builder/class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
@@ -18,13 +18,14 @@
Supertype,
getAsTypeArguments;
import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
-import 'package:kernel/src/legacy_erasure.dart';
+import 'package:kernel/src/unaliasing.dart';
import 'package:kernel/text/text_serialization_verifier.dart';
import '../fasta_codes.dart';
import '../modifier.dart';
import '../problems.dart' show internalProblem, unhandled;
import '../scope.dart';
+import '../source/source_library_builder.dart';
import '../type_inference/type_schema.dart' show UnknownType;
import 'builder.dart';
import 'declaration_builder.dart';
@@ -98,10 +99,7 @@
InterfaceType rawType(Nullability nullability);
- List<DartType> buildTypeArguments(
- LibraryBuilder library, List<TypeBuilder>? arguments);
-
- Supertype buildSupertype(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments);
Supertype buildMixedInType(
@@ -310,8 +308,14 @@
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType>? arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
assert(arguments == null || cls.typeParameters.length == arguments.length);
if (isNullClass) {
return const NullType();
@@ -324,31 +328,33 @@
return new FutureOrType(arguments!.single, nullability);
}
}
- return arguments == null
+ DartType type = arguments == null
? rawType(nullability)
: new InterfaceType(cls, nullability, arguments);
+ if (typeVariablesCount != 0 && library is SourceLibraryBuilder) {
+ library.registerBoundsCheck(type, fileUri, charOffset, typeUse,
+ inferred: !hasExplicitTypeArguments);
+ }
+ return type;
}
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
- return buildTypeWithBuiltArguments(
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
+ return buildAliasedTypeWithBuiltArguments(
library,
nullabilityBuilder.build(library),
- buildTypeArguments(library, arguments));
- }
-
- @override
- Supertype buildSupertype(
- LibraryBuilder library, List<TypeBuilder>? arguments) {
- Class cls = isPatch ? origin.cls : this.cls;
- List<DartType> typeArguments = buildTypeArguments(library, arguments);
- if (!library.isNonNullableByDefault) {
- for (int i = 0; i < typeArguments.length; ++i) {
- typeArguments[i] = legacyErasure(typeArguments[i]);
- }
- }
- return new Supertype(cls, typeArguments);
+ buildAliasedTypeArguments(library, arguments),
+ typeUse,
+ fileUri,
+ charOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
}
@override
@@ -356,7 +362,11 @@
LibraryBuilder library, List<TypeBuilder>? arguments) {
Class cls = isPatch ? origin.cls : this.cls;
if (arguments != null) {
- return new Supertype(cls, buildTypeArguments(library, arguments));
+ List<DartType> typeArguments =
+ buildAliasedTypeArguments(library, arguments);
+ typeArguments = unaliasTypes(typeArguments,
+ legacyEraseAliases: !library.isNonNullableByDefault)!;
+ return new Supertype(cls, typeArguments);
} else {
return new Supertype(
cls,
diff --git a/pkg/front_end/lib/src/fasta/builder/extension_builder.dart b/pkg/front_end/lib/src/fasta/builder/extension_builder.dart
index f0deb80..5272f53 100644
--- a/pkg/front_end/lib/src/fasta/builder/extension_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/extension_builder.dart
@@ -72,14 +72,24 @@
}
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
if (library is SourceLibraryBuilder &&
library.libraryFeatures.extensionTypes.isEnabled) {
- return buildTypeWithBuiltArguments(
+ return buildAliasedTypeWithBuiltArguments(
library,
nullabilityBuilder.build(library),
- _buildTypeArguments(library, arguments));
+ _buildAliasedTypeArguments(library, arguments),
+ typeUse,
+ fileUri,
+ charOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
} else {
throw new UnsupportedError("ExtensionBuilder.buildType is not supported"
"in library '${library.importUri}'.");
@@ -87,8 +97,14 @@
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
if (library is SourceLibraryBuilder &&
library.libraryFeatures.extensionTypes.isEnabled) {
return new ExtensionType(extension, nullability, arguments);
@@ -102,7 +118,7 @@
@override
int get typeVariablesCount => typeParameters?.length ?? 0;
- List<DartType> _buildTypeArguments(
+ List<DartType> _buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments) {
if (arguments == null && typeParameters == null) {
return <DartType>[];
@@ -111,7 +127,9 @@
if (arguments == null && typeParameters != null) {
List<DartType> result =
new List<DartType>.generate(typeParameters!.length, (int i) {
- return typeParameters![i].defaultType!.build(library);
+ return typeParameters![i]
+ .defaultType!
+ .buildAliased(library, TypeUse.defaultTypeAsTypeArgument);
}, growable: true);
if (library is SourceLibraryBuilder) {
library.inferredTypes.addAll(result);
@@ -133,7 +151,7 @@
assert(arguments!.length == typeVariablesCount);
List<DartType> result =
new List<DartType>.generate(arguments!.length, (int i) {
- return arguments[i].build(library);
+ return arguments[i].buildAliased(library, TypeUse.typeArgument);
}, growable: true);
return result;
}
diff --git a/pkg/front_end/lib/src/fasta/builder/fixed_type_builder.dart b/pkg/front_end/lib/src/fasta/builder/fixed_type_builder.dart
index 44e408f..92bcd1d 100644
--- a/pkg/front_end/lib/src/fasta/builder/fixed_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/fixed_type_builder.dart
@@ -48,7 +48,12 @@
}
@override
- DartType build(LibraryBuilder library) {
+ DartType build(LibraryBuilder library, TypeUse typeUse) {
+ return type;
+ }
+
+ @override
+ DartType buildAliased(LibraryBuilder library, TypeUse typeUse) {
return type;
}
diff --git a/pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart b/pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart
index 68f16e3..2832049 100644
--- a/pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart
@@ -145,7 +145,7 @@
VariableDeclaration build(
SourceLibraryBuilder library, int functionNestingLevel) {
if (variable == null) {
- DartType? builtType = type?.build(library);
+ DartType? builtType = type?.build(library, TypeUse.parameterType);
variable = new VariableDeclarationImpl(
name == noNameSentinel ? null : name, functionNestingLevel,
type: builtType,
diff --git a/pkg/front_end/lib/src/fasta/builder/function_type_builder.dart b/pkg/front_end/lib/src/fasta/builder/function_type_builder.dart
index f972a4d0..30493a8 100644
--- a/pkg/front_end/lib/src/fasta/builder/function_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/function_type_builder.dart
@@ -12,6 +12,7 @@
NamedType,
Supertype,
TypeParameter;
+import 'package:kernel/src/unaliasing.dart';
import '../fasta_codes.dart' show messageSupertypeIsFunction, noLength;
@@ -84,19 +85,29 @@
}
@override
- FunctionType build(LibraryBuilder library) {
- return _type ??= _buildInternal(library);
+ FunctionType build(LibraryBuilder library, TypeUse typeUse) {
+ return _type ??= _buildInternal(library, typeUse) as FunctionType;
}
- FunctionType _buildInternal(LibraryBuilder library) {
+ DartType _buildInternal(LibraryBuilder library, TypeUse typeUse) {
+ DartType aliasedType = buildAliased(library, typeUse);
+ return unalias(aliasedType,
+ legacyEraseAliases: !library.isNonNullableByDefault);
+ }
+
+ @override
+ DartType buildAliased(LibraryBuilder library, TypeUse typeUse) {
DartType builtReturnType =
- returnType?.build(library) ?? const DynamicType();
+ returnType?.buildAliased(library, TypeUse.returnType) ??
+ const DynamicType();
List<DartType> positionalParameters = <DartType>[];
List<NamedType>? namedParameters;
int requiredParameterCount = 0;
if (formals != null) {
for (ParameterBuilder formal in formals!) {
- DartType type = formal.type?.build(library) ?? const DynamicType();
+ DartType type =
+ formal.type?.buildAliased(library, TypeUse.parameterType) ??
+ const DynamicType();
if (formal.isPositional) {
positionalParameters.add(type);
if (formal.isRequiredPositional) requiredParameterCount++;
@@ -116,7 +127,7 @@
for (TypeVariableBuilder t in typeVariables!) {
typeParameters.add(t.parameter);
// Build the bound to detect cycles in typedefs.
- t.bound?.build(library);
+ t.bound?.build(library, TypeUse.typeParameterBound);
}
}
return new FunctionType(positionalParameters, builtReturnType,
diff --git a/pkg/front_end/lib/src/fasta/builder/future_or_type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/future_or_type_declaration_builder.dart
index 277a400..fb47efbb 100644
--- a/pkg/front_end/lib/src/fasta/builder/future_or_type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/future_or_type_declaration_builder.dart
@@ -20,15 +20,28 @@
String get debugName => "FutureOrTypeDeclarationBuilder";
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return new FutureOrType(
- arguments!.single.build(library), nullabilityBuilder.build(library));
+ arguments!.single.buildAliased(library, TypeUse.typeArgument),
+ nullabilityBuilder.build(library));
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return new FutureOrType(arguments.single, nullability);
}
}
diff --git a/pkg/front_end/lib/src/fasta/builder/invalid_type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/invalid_type_declaration_builder.dart
index 5f2b68b..82d2ccc 100644
--- a/pkg/front_end/lib/src/fasta/builder/invalid_type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/invalid_type_declaration_builder.dart
@@ -33,15 +33,29 @@
Uri? get fileUri => message.uri;
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
- return buildTypeWithBuiltArguments(library, null, null);
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
+ return buildAliasedTypeWithBuiltArguments(
+ library, null, null, typeUse, fileUri, charOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
}
/// [Arguments] have already been built.
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability? nullability, List<DartType>? arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability? nullability,
+ List<DartType>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
if (!suppressMessage) {
library.addProblem(message.messageObject, message.charOffset,
message.length, message.uri,
diff --git a/pkg/front_end/lib/src/fasta/builder/named_type_builder.dart b/pkg/front_end/lib/src/fasta/builder/named_type_builder.dart
index f4f08fe..036806f 100644
--- a/pkg/front_end/lib/src/fasta/builder/named_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/named_type_builder.dart
@@ -5,6 +5,8 @@
library fasta.named_type_builder;
import 'package:kernel/ast.dart';
+import 'package:kernel/src/legacy_erasure.dart';
+import 'package:kernel/src/unaliasing.dart';
import '../fasta_codes.dart'
show
@@ -25,15 +27,11 @@
templateTypeArgumentMismatch,
templateTypeArgumentsOnTypeVariable,
templateTypeNotFound;
-
import '../identifiers.dart' show Identifier, QualifiedName, flattenName;
-
import '../problems.dart' show unhandled;
-
import '../scope.dart';
-
import '../source/source_library_builder.dart';
-
+import '../uris.dart';
import 'builder.dart';
import 'builtin_type_declaration_builder.dart';
import 'class_builder.dart';
@@ -114,6 +112,8 @@
DartType? _type;
+ final bool hasExplicitTypeArguments;
+
NamedTypeBuilder(this.name, this.nullabilityBuilder,
{this.arguments,
this.fileUri,
@@ -122,7 +122,8 @@
bool forTypeLiteral: false})
: assert(name is String || name is QualifiedName),
this._instanceTypeVariableAccess = instanceTypeVariableAccess,
- this._forTypeLiteral = forTypeLiteral;
+ this._forTypeLiteral = forTypeLiteral,
+ this.hasExplicitTypeArguments = arguments != null;
NamedTypeBuilder.forDartType(DartType this._type,
TypeDeclarationBuilder this._declaration, this.nullabilityBuilder,
@@ -132,7 +133,8 @@
InstanceTypeVariableAccessState.Unexpected,
this.fileUri = null,
this.charOffset = null,
- this._forTypeLiteral = false;
+ this._forTypeLiteral = false,
+ this.hasExplicitTypeArguments = arguments != null;
NamedTypeBuilder.fromTypeDeclarationBuilder(
TypeDeclarationBuilder this._declaration, this.nullabilityBuilder,
@@ -144,7 +146,8 @@
: this.name = _declaration.name,
this._forTypeLiteral = false,
this._instanceTypeVariableAccess = instanceTypeVariableAccess,
- this._type = type;
+ this._type = type,
+ this.hasExplicitTypeArguments = arguments != null;
NamedTypeBuilder.forInvalidType(
String this.name, this.nullabilityBuilder, LocatedMessage message,
@@ -156,7 +159,8 @@
this._instanceTypeVariableAccess =
InstanceTypeVariableAccessState.Unexpected,
this._forTypeLiteral = false,
- this._type = const InvalidType();
+ this._type = const InvalidType(),
+ this.hasExplicitTypeArguments = false;
@override
TypeDeclarationBuilder? get declaration => _declaration;
@@ -378,55 +382,57 @@
}
@override
- DartType build(LibraryBuilder library) {
- return _type ??= _buildInternal(library);
+ DartType build(LibraryBuilder library, TypeUse typeUse) {
+ return _type ??= _buildInternal(library, typeUse);
}
- DartType _declarationBuildType(LibraryBuilder library) {
- if (_forTypeLiteral) {
- return declaration!
- .buildTypeLiteralType(library, nullabilityBuilder, arguments);
- } else {
- return declaration!.buildType(library, nullabilityBuilder, arguments);
- }
+ DartType _buildInternal(LibraryBuilder library, TypeUse typeUse) {
+ DartType aliasedType = _buildAliasedInternal(library, typeUse);
+ return unalias(aliasedType,
+ legacyEraseAliases:
+ !_forTypeLiteral && !library.isNonNullableByDefault);
}
- DartType _buildInternal(LibraryBuilder library) {
+ @override
+ DartType buildAliased(LibraryBuilder library, TypeUse typeUse) {
+ return _buildAliasedInternal(library, typeUse);
+ }
+
+ DartType _buildAliasedInternal(LibraryBuilder library, TypeUse typeUse) {
assert(declaration != null, "Declaration has not been resolved on $this.");
- if (library is SourceLibraryBuilder) {
- int uncheckedTypedefTypeCount = library.uncheckedTypedefTypes.length;
- DartType builtType = _declarationBuildType(library);
- // Set locations for new unchecked TypedefTypes for error reporting.
- for (int i = uncheckedTypedefTypeCount;
- i < library.uncheckedTypedefTypes.length;
- ++i) {
- // TODO(johnniwinther): Pass the uri/offset through the build methods
- // to avoid this.
- library.uncheckedTypedefTypes[i]
- ..fileUri ??= fileUri
- ..offset ??= charOffset;
- }
- return builtType;
- } else {
- return _declarationBuildType(library);
- }
+ return declaration!.buildAliasedType(library, nullabilityBuilder, arguments,
+ typeUse, fileUri ?? missingUri, charOffset ?? TreeNode.noOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
}
@override
Supertype? buildSupertype(LibraryBuilder library) {
TypeDeclarationBuilder declaration = this.declaration!;
if (declaration is ClassBuilder) {
- if (declaration.isNullClass && !library.mayImplementRestrictedTypes) {
- library.addProblem(
- templateExtendingRestricted.withArguments(declaration.name),
- charOffset!,
- noLength,
- fileUri);
+ if (declaration.isNullClass) {
+ if (!library.mayImplementRestrictedTypes) {
+ library.addProblem(
+ templateExtendingRestricted.withArguments(declaration.name),
+ charOffset!,
+ noLength,
+ fileUri);
+ }
}
- return declaration.buildSupertype(library, arguments);
+ DartType type = build(library, TypeUse.superType);
+ if (type is InterfaceType) {
+ if (!library.isNonNullableByDefault) {
+ // This "normalizes" type argument `Never*` to `Null`.
+ type = legacyErasure(type) as InterfaceType;
+ }
+ return new Supertype(type.classNode, type.typeArguments);
+ } else if (type is FutureOrType) {
+ return new Supertype(declaration.cls, [type.typeArgument]);
+ } else if (type is NullType) {
+ return new Supertype(declaration.cls, []);
+ }
} else if (declaration is TypeAliasBuilder) {
TypeAliasBuilder aliasBuilder = declaration;
- DartType type = build(library);
+ DartType type = build(library, TypeUse.superType);
if (type is InterfaceType && type.nullability != Nullability.nullable) {
return new Supertype(type.classNode, type.typeArguments);
} else if (type is NullType) {
@@ -490,7 +496,7 @@
return declaration.buildMixedInType(library, arguments);
} else if (declaration is TypeAliasBuilder) {
TypeAliasBuilder aliasBuilder = declaration;
- DartType type = build(library);
+ DartType type = build(library, TypeUse.mixedInType);
if (type is InterfaceType && type.nullability != Nullability.nullable) {
return new Supertype(type.classNode, type.typeArguments);
}
diff --git a/pkg/front_end/lib/src/fasta/builder/never_type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/never_type_declaration_builder.dart
index 2e2c1b5..20389ed 100644
--- a/pkg/front_end/lib/src/fasta/builder/never_type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/never_type_declaration_builder.dart
@@ -10,27 +10,40 @@
import 'library_builder.dart';
import 'nullability_builder.dart';
import 'type_builder.dart';
+import '../uris.dart';
class NeverTypeDeclarationBuilder extends BuiltinTypeDeclarationBuilder {
final LibraryBuilder coreLibrary;
NeverTypeDeclarationBuilder(DartType type, this.coreLibrary, int charOffset)
: super("Never", type, coreLibrary, charOffset) {
- assert(coreLibrary.importUri == Uri.parse('dart:core'));
+ assert(coreLibrary.importUri == dartCore);
}
@override
String get debugName => "NeverTypeDeclarationBuilder";
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type.withDeclaredNullability(nullabilityBuilder.build(library));
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type.withDeclaredNullability(nullability);
}
}
diff --git a/pkg/front_end/lib/src/fasta/builder/null_type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/null_type_declaration_builder.dart
index 818c6f0..945aa07 100644
--- a/pkg/front_end/lib/src/fasta/builder/null_type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/null_type_declaration_builder.dart
@@ -20,14 +20,26 @@
String get debugName => "NullTypeBuilder";
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type;
}
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments) {
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
return type;
}
}
diff --git a/pkg/front_end/lib/src/fasta/builder/type_alias_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_alias_builder.dart
index ad7bceb..3b977bc 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_alias_builder.dart
@@ -5,9 +5,6 @@
library fasta.function_type_alias_builder;
import 'package:kernel/ast.dart';
-import 'package:kernel/src/legacy_erasure.dart';
-
-import 'package:kernel/type_algebra.dart' show substitute, uniteNullabilities;
import '../fasta_codes.dart'
show
@@ -55,12 +52,7 @@
DartType buildThisType();
- /// [arguments] have already been built.
- @override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType>? arguments);
-
- List<DartType> buildTypeArguments(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments);
/// Returns `true` if this typedef is an alias of the `Null` type.
@@ -153,81 +145,50 @@
/// [arguments] have already been built.
@override
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType>? arguments) {
- DartType thisType = buildThisType();
- if (const DynamicType() == thisType) return thisType;
- Nullability adjustedNullability =
- isNullAlias ? Nullability.nullable : nullability;
- DartType result = thisType.withDeclaredNullability(adjustedNullability);
- // TODO(johnniwinther): Couldn't [arguments] be null and
- // `typedef.typeParameters` be non-empty?
- if (typedef.typeParameters.isEmpty && arguments == null) return result;
- Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
- for (int i = 0; i < typedef.typeParameters.length; i++) {
- substitution[typedef.typeParameters[i]] = arguments![i];
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
+ buildThisType();
+ TypedefType type = new TypedefType(typedef, nullability, arguments);
+ if (library is SourceLibraryBuilder) {
+ if (typeVariablesCount != 0) {
+ library.registerBoundsCheck(type, fileUri, charOffset, typeUse,
+ inferred: !hasExplicitTypeArguments);
+ }
+ if (!library.libraryFeatures.genericMetadata.isEnabled) {
+ library.registerGenericFunctionTypeCheck(type, fileUri, charOffset);
+ }
}
- // The following adds the built type to the list of unchecked typedef types
- // of the client library. It is needed because the type is built unaliased,
- // and at the time of the check it wouldn't be possible to see if the type
- // arguments to the generic typedef conform to the bounds without preserving
- // the TypedefType for the delayed check.
- if (library is SourceLibraryBuilder &&
- arguments!.isNotEmpty &&
- thisType is! FunctionType) {
- library.uncheckedTypedefTypes.add(new UncheckedTypedefType(
- new TypedefType(typedef, nullability, arguments)));
- }
- return substitute(result, substitution);
+
+ return type;
}
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
- return buildTypeInternal(library, nullabilityBuilder, arguments,
- performLegacyErasure: true);
- }
-
- @override
- DartType buildTypeLiteralType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
- return buildTypeInternal(library, nullabilityBuilder, arguments,
- performLegacyErasure: false);
- }
-
- DartType buildTypeInternal(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments,
- {required bool performLegacyErasure}) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
DartType thisType = buildThisType();
if (thisType is InvalidType) return thisType;
- // The following won't work if the right-hand side of the typedef is a
- // FutureOr.
- Nullability nullability;
- if (isNullAlias) {
- // Null is always nullable.
- nullability = Nullability.nullable;
- } else if (!parent.isNonNullableByDefault ||
- !library.isNonNullableByDefault) {
- // The typedef is defined or used in an opt-out library so the nullability
- // is based on the use site alone.
- nullability = nullabilityBuilder.build(library);
- } else {
- nullability = uniteNullabilities(
- thisType.declaredNullability, nullabilityBuilder.build(library));
- }
- DartType result;
- if (typedef.typeParameters.isEmpty && arguments == null) {
- result = thisType.withDeclaredNullability(nullability);
- } else {
- // Otherwise, substitute.
- result = buildTypeWithBuiltArguments(
- library, nullability, buildTypeArguments(library, arguments));
- }
- if (performLegacyErasure && !library.isNonNullableByDefault) {
- result = legacyErasure(result);
- }
- return result;
+ Nullability nullability = nullabilityBuilder.build(library);
+ return buildAliasedTypeWithBuiltArguments(
+ library,
+ nullability,
+ buildAliasedTypeArguments(library, arguments),
+ typeUse,
+ fileUri,
+ charOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
}
TypeDeclarationBuilder? _cachedUnaliasedDeclaration;
diff --git a/pkg/front_end/lib/src/fasta/builder/type_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
index 72d12fa..0090e6f 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
@@ -13,6 +13,249 @@
import 'type_declaration_builder.dart';
import 'type_variable_builder.dart';
+enum TypeUse {
+ /// A type used as the type of a parameter.
+ ///
+ /// For instance `X` and `Y` in
+ ///
+ /// method(X p, {Y q}) {}
+ ///
+ parameterType,
+
+ /// A type used as the type of a field.
+ ///
+ /// For instance `X` and `Y` in
+ ///
+ /// X topLevelField;
+ /// class Class {
+ /// Y instanceField;
+ /// }
+ ///
+ fieldType,
+
+ /// A type used as the return type of a function.
+ ///
+ /// For instance `X` in
+ ///
+ /// X method() { ... }
+ ///
+ returnType,
+
+ /// A type used as a type argument to a constructor invocation.
+ ///
+ /// For instance `X` in
+ ///
+ /// class Class<T> {}
+ /// method() => new Class<X>();
+ ///
+ constructorTypeArgument,
+
+ /// A type used as a type argument to a redirecting factory constructor
+ /// declaration.
+ ///
+ /// For instance `X` in
+ ///
+ /// class Class<T> {
+ /// Class();
+ /// factory Class.redirect() = Class<X>;
+ /// }
+ ///
+ redirectionTypeArgument,
+
+ /// A type used as the bound of a type parameter.
+ ///
+ /// For instance `X` and `Y` in
+ ///
+ /// method<T extends X>() {}
+ /// class Class<S extends Y> {}
+ ///
+ typeParameterBound,
+
+ /// A type computed as the default type for a type parameter.
+ ///
+ /// For instance the type `X` computed for `T` and the type `dynamic` computed
+ /// for `S`.
+ ///
+ /// method<T extends X>() {}
+ /// class Class<S> {}
+ ///
+ typeParameterDefaultType,
+
+ /// A type used as a type argument in the instantiation of a tear off.
+ ///
+ /// For instance `X` and `Y` in
+ ///
+ /// class Class<S> {}
+ /// method<T>() {
+ /// Class<X>.new;
+ /// method<Y>;
+ /// }
+ ///
+ tearOffTypeArgument,
+
+ /// A type used in an extends, with or implements clause.
+ ///
+ /// For instance `X`, `Y`, `Z` in
+ ///
+ /// class Class extends X with Y implements Z {}
+ ///
+ // TODO(johnniwinther): The probably enclosed the mixin on clause. Is this
+ // a correct handling wrt well-boundedness?
+ superType,
+
+ /// A type used in a with clause.
+ ///
+ /// For instance `X` in
+ ///
+ /// class Class extends X {}
+ ///
+ /// This type use creates an intermediate type used for mixin inference. The
+ /// type is not check for well-boundedness and contains [UnknownType] where
+ /// type arguments are omitted.
+ mixedInType,
+
+ /// A type used in the on clause of an extension declaration.
+ ///
+ /// For instance `X` in
+ ///
+ /// extension Extension on X {}
+ ///
+ extensionOnType,
+
+ /// A type used as the definition of a typedef.
+ ///
+ /// For instance `X`, `void Function()` in
+ ///
+ /// typedef Typedef1 = X;
+ /// typedef void Typedef2(); // The unaliased type is `void Function()`.
+ ///
+ typedefAlias,
+
+ /// An internally created function type used when build local functions.
+ functionSignature,
+
+ /// The this type of an enum.
+ // TODO(johnniwinther): This is doesn't currently have the correct value
+ // and/or well-boundedness checking.
+ enumSelfType,
+
+ /// A type used as a type literal.
+ ///
+ /// For instance `X` in
+ ///
+ /// method() => X;
+ ///
+ /// where `X` is the name of a class.
+ typeLiteral,
+
+ /// A type used as a type argument to a literal.
+ ///
+ /// For instance `X`, `Y`, `Z`, and `W` in
+ ///
+ /// method() {
+ /// <X>[];
+ /// <Y>{};
+ /// <Z, W>{};
+ /// }
+ ///
+ literalTypeArgument,
+
+ /// A type used as a type argument in an invocation.
+ ///
+ /// For instance `X`, `Y`, and `Z` in
+ ///
+ /// staticMethod<T>(Class c, void Function<S>() f) {
+ /// staticMethod<X>(c, f);
+ /// c.instanceMethod<Y>();
+ /// f<Z>();
+ /// }
+ /// class Class {
+ /// instanceMethod<U>() {}
+ /// }
+ invocationTypeArgument,
+
+ /// A type used as the type in an is-test.
+ ///
+ /// For instance `X` in
+ ///
+ /// method(o) => o is X;
+ ///
+ isType,
+
+ /// A type used as the type in an as-cast.
+ ///
+ /// For instance `X` in
+ ///
+ /// method(o) => o as X;
+ ///
+ asType,
+
+ /// A type used as the type of local variable.
+ ///
+ /// For instance `X` in
+ ///
+ /// method() {
+ /// X local;
+ /// }
+ ///
+ variableType,
+
+ /// A type used as the catch type in a catch clause.
+ ///
+ /// For instance `X` in
+ ///
+ /// method() {
+ /// try {
+ /// } on X catch (e) {
+ /// }
+ /// }
+ ///
+ catchType,
+
+ /// A type used as an instantiation argument.
+ ///
+ /// For instance `X` in
+ ///
+ /// method(void Function<T>() f) {
+ /// f<X>;
+ /// }
+ ///
+ instantiation,
+
+ /// A type used as a type argument within another type.
+ ///
+ /// For instance `X`, `Y`, `Z` and `W` in
+ ///
+ /// method(List<X> a, Y Function(Z) f) {}
+ /// class Class implements List<W> {}
+ ///
+ typeArgument,
+
+ /// The default type of a type parameter used as the type argument in a raw
+ /// type.
+ ///
+ /// For instance `X` implicitly inside `Class<X>` in the type of `cls` in
+ ///
+ /// class Class<T extends X> {}
+ /// Class cls;
+ ///
+ defaultTypeAsTypeArgument,
+
+ /// A type from a deferred library. This is an error case.
+ ///
+ /// For instance `X` in
+ ///
+ /// import 'foo.dart' deferred as prefix;
+ ///
+ /// prefix.X field;
+ ///
+ deferredTypeError,
+
+ /// A type used as a type argument in the construction of a type through the
+ /// macro API.
+ macroTypeArgument,
+}
+
abstract class TypeBuilder {
const TypeBuilder();
@@ -60,7 +303,23 @@
String get fullNameForErrors => "${printOn(new StringBuffer())}";
- DartType build(LibraryBuilder library);
+ /// Creates the [DartType] from this [TypeBuilder] that doesn't contain
+ /// [TypedefType].
+ ///
+ /// [library] is used to determine nullabilities and for registering well-
+ /// boundedness checks on the created type. [typeUse] describes how the
+ /// type is used which determine which well-boundedness checks are applied.
+ DartType build(LibraryBuilder library, TypeUse typeUse);
+
+ /// Creates the [DartType] from this [TypeBuilder] that contains
+ /// [TypedefType]. This is used to create types internal on which well-
+ /// boundedness checks can be permit. Calls from outside the [TypeBuilder]
+ /// subclasses should generally use [build] instead.
+ ///
+ /// [library] is used to determine nullabilities and for registering well-
+ /// boundedness checks on the created type. [typeUse] describes how the
+ /// type is used which determine which well-boundedness checks are applied.
+ DartType buildAliased(LibraryBuilder library, TypeUse typeUse);
Supertype? buildSupertype(LibraryBuilder library);
diff --git a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
index 1e51ffb..d8df153 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
@@ -33,22 +33,32 @@
/// Creates the [DartType] corresponding to this declaration applied with
/// [arguments] in [library] with the syntactical nullability defined by
- /// [nullabilityBuilder].
+ /// [nullabilityBuilder]. The created type will contain [TypedefType] instead
+ /// of their unaliased type.
///
/// For instance, if this declaration is a class declaration `C`, then
/// an occurrence of `C<int>?` in a null safe library `lib1` would call
/// `buildType(<lib1>, <?>, [<int>])` to create `C<int>?`, or `C<int>` in a
/// legacy library `lib2` call `buildType(<lib2>, <> [<int>]` to create
/// `C<int*>*`.
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments);
-
- DartType buildTypeLiteralType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments);
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments});
/// [arguments] have already been built.
- DartType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType> arguments);
+ DartType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType> arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments});
}
abstract class TypeDeclarationBuilderImpl extends ModifierBuilderImpl
@@ -85,10 +95,4 @@
@override
int get typeVariablesCount => 0;
-
- @override
- DartType buildTypeLiteralType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
- return buildType(library, nullabilityBuilder, arguments);
- }
}
diff --git a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
index 79a2d15..3cc96e2 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
@@ -15,6 +15,7 @@
import '../scope.dart';
import '../source/source_library_builder.dart';
+import '../uris.dart';
import '../util/helpers.dart';
import 'builder.dart';
@@ -119,11 +120,15 @@
}
@override
- DartType buildType(LibraryBuilder library,
- NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
+ DartType buildAliasedType(
+ LibraryBuilder library,
+ NullabilityBuilder nullabilityBuilder,
+ List<TypeBuilder>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
if (arguments != null) {
- int charOffset = -1; // TODO(ahe): Provide these.
- Uri? fileUri = null; // TODO(ahe): Provide these.
library.addProblem(
templateTypeArgumentsOnTypeVariable.withArguments(name),
charOffset,
@@ -148,26 +153,34 @@
} else {
nullability = nullabilityBuilder.build(library);
}
- TypeParameterType type =
- buildTypeWithBuiltArguments(library, nullability, null);
+ TypeParameterType type = buildAliasedTypeWithBuiltArguments(
+ library, nullability, null, typeUse, fileUri, charOffset,
+ hasExplicitTypeArguments: hasExplicitTypeArguments);
if (needsPostUpdate) {
if (library is SourceLibraryBuilder) {
- library.registerPendingNullability(fileUri!, charOffset, type);
+ library.registerPendingNullability(
+ this.fileUri!, this.charOffset, type);
} else {
library.addProblem(
templateInternalProblemUnfinishedTypeVariable.withArguments(
name, library.importUri),
- charOffset,
+ this.charOffset,
name.length,
- fileUri);
+ this.fileUri);
}
}
return type;
}
@override
- TypeParameterType buildTypeWithBuiltArguments(LibraryBuilder library,
- Nullability nullability, List<DartType>? arguments) {
+ TypeParameterType buildAliasedTypeWithBuiltArguments(
+ LibraryBuilder library,
+ Nullability nullability,
+ List<DartType>? arguments,
+ TypeUse typeUse,
+ Uri fileUri,
+ int charOffset,
+ {required bool hasExplicitTypeArguments}) {
if (arguments != null) {
int charOffset = -1; // TODO(ahe): Provide these.
Uri? fileUri = null; // TODO(ahe): Provide these.
@@ -183,10 +196,17 @@
void finish(
LibraryBuilder library, ClassBuilder object, TypeBuilder dynamicType) {
if (isPatch) return;
- DartType objectType =
- object.buildType(library, library.nullableBuilder, null);
+ DartType objectType = object.buildAliasedType(
+ library,
+ library.nullableBuilder,
+ null,
+ TypeUse.typeParameterBound,
+ fileUri ?? missingUri,
+ charOffset,
+ hasExplicitTypeArguments: false);
if (identical(parameter.bound, TypeParameter.unsetBoundSentinel)) {
- parameter.bound = bound?.build(library) ?? objectType;
+ parameter.bound =
+ bound?.build(library, TypeUse.typeParameterBound) ?? objectType;
}
// If defaultType is not set, initialize it to dynamic, unless the bound is
// explicitly specified as Object, in which case defaultType should also be
@@ -194,10 +214,11 @@
// explicit Object bound results in Object as the instantiated type.
if (identical(
parameter.defaultType, TypeParameter.unsetDefaultTypeSentinel)) {
- parameter.defaultType = defaultType?.build(library) ??
+ parameter.defaultType = defaultType?.build(
+ library, TypeUse.typeParameterDefaultType) ??
(bound != null && parameter.bound == objectType
? objectType
- : dynamicType.build(library));
+ : dynamicType.build(library, TypeUse.typeParameterDefaultType));
}
}
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_class_builder.dart b/pkg/front_end/lib/src/fasta/dill/dill_class_builder.dart
index 66976b6..b245233 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_class_builder.dart
@@ -134,20 +134,21 @@
int get typeVariablesCount => cls.typeParameters.length;
@override
- List<DartType> buildTypeArguments(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments) {
// For performance reasons, [typeVariables] aren't restored from [target].
// So, if [arguments] is null, the default types should be retrieved from
// [cls.typeParameters].
if (arguments == null) {
+ // TODO(johnniwinther): Use i2b here when needed.
return new List<DartType>.generate(cls.typeParameters.length,
(int i) => cls.typeParameters[i].defaultType,
growable: true);
}
// [arguments] != null
- return new List<DartType>.generate(
- arguments.length, (int i) => arguments[i].build(library),
+ return new List<DartType>.generate(arguments.length,
+ (int i) => arguments[i].buildAliased(library, TypeUse.typeArgument),
growable: true);
}
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_library_builder.dart b/pkg/front_end/lib/src/fasta/dill/dill_library_builder.dart
index a1584e3..7c94a5a 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_library_builder.dart
@@ -282,10 +282,6 @@
}
void addTypedef(Typedef typedef, Map<Name, Procedure>? tearOffs) {
- DartType? type = typedef.type;
- if (type is FunctionType && type.typedefType == null) {
- unhandled("null", "addTypedef", typedef.fileOffset, typedef.fileUri);
- }
_addBuilder(
typedef.name, new DillTypeAliasBuilder(typedef, tearOffs, this));
}
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_loader.dart b/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
index 4665e61..bc00908 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_loader.dart
@@ -38,6 +38,8 @@
import '../ticker.dart' show Ticker;
+import '../uris.dart';
+
import 'dill_library_builder.dart' show DillLibraryBuilder;
import 'dill_target.dart' show DillTarget;
@@ -226,6 +228,8 @@
List<LocatedMessage>? context,
bool problemOnLibrary: false,
List<Uri>? involvedFiles}) {
+ assert(
+ fileUri != missingUri, "Message unexpectedly reported on missing uri.");
severity ??= message.code.severity;
if (severity == Severity.ignored) return null;
String trace = """
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_type_alias_builder.dart b/pkg/front_end/lib/src/fasta/dill/dill_type_alias_builder.dart
index e777b52..92df2a0 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_type_alias_builder.dart
@@ -73,12 +73,13 @@
}
@override
- List<DartType> buildTypeArguments(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments) {
// For performance reasons, [typeVariables] aren't restored from [target].
// So, if [arguments] is null, the default types should be retrieved from
// [cls.typeParameters].
if (arguments == null) {
+ // TODO(johnniwinther): Use i2b here when needed.
List<DartType> result =
new List<DartType>.generate(typedef.typeParameters.length, (int i) {
return typedef.typeParameters[i].defaultType;
@@ -89,7 +90,7 @@
// [arguments] != null
List<DartType> result =
new List<DartType>.generate(arguments.length, (int i) {
- return arguments[i].build(library);
+ return arguments[i].buildAliased(library, TypeUse.typeArgument);
}, growable: true);
return result;
}
diff --git a/pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart b/pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart
index f786f84..f97e08e 100644
--- a/pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart
+++ b/pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart
@@ -1346,6 +1346,46 @@
}
// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+ Message Function(
+ DartType _type, DartType _type2, bool isNonNullableByDefault)>
+ templateGenericFunctionTypeAsTypeArgumentThroughTypedef = const Template<
+ Message Function(
+ DartType _type, DartType _type2, bool isNonNullableByDefault)>(
+ problemMessageTemplate:
+ r"""Generic function type '#type' used as a type argument through typedef '#type2'.""",
+ correctionMessageTemplate:
+ r"""Try providing a non-generic function type explicitly.""",
+ withArguments:
+ _withArgumentsGenericFunctionTypeAsTypeArgumentThroughTypedef);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<
+ Message Function(
+ DartType _type, DartType _type2, bool isNonNullableByDefault)>
+ codeGenericFunctionTypeAsTypeArgumentThroughTypedef = const Code<
+ Message Function(
+ DartType _type, DartType _type2, bool isNonNullableByDefault)>(
+ "GenericFunctionTypeAsTypeArgumentThroughTypedef",
+ analyzerCodes: <String>["GENERIC_FUNCTION_CANNOT_BE_TYPE_ARGUMENT"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsGenericFunctionTypeAsTypeArgumentThroughTypedef(
+ DartType _type, DartType _type2, bool isNonNullableByDefault) {
+ TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+ List<Object> typeParts = labeler.labelType(_type);
+ List<Object> type2Parts = labeler.labelType(_type2);
+ String type = typeParts.join();
+ String type2 = type2Parts.join();
+ return new Message(codeGenericFunctionTypeAsTypeArgumentThroughTypedef,
+ problemMessage:
+ """Generic function type '${type}' used as a type argument through typedef '${type2}'.""" +
+ labeler.originMessages,
+ correctionMessage: """Try providing a non-generic function type explicitly.""",
+ arguments: {'type': _type, 'type2': _type2});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
const Template<Message Function(DartType _type, bool isNonNullableByDefault)>
templateGenericFunctionTypeInferredAsActualTypeArgument = const Template<
Message Function(DartType _type, bool isNonNullableByDefault)>(
@@ -1535,224 +1575,6 @@
const Template<
Message Function(DartType _type, DartType _type2, String name,
String name2, bool isNonNullableByDefault)>
- templateIncorrectTypeArgumentInReturnType = const Template<
- Message Function(DartType _type, DartType _type2, String name,
- String name2, bool isNonNullableByDefault)>(
- problemMessageTemplate:
- r"""Type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the return type.""",
- correctionMessageTemplate:
- r"""Try changing type arguments so that they conform to the bounds.""",
- withArguments: _withArgumentsIncorrectTypeArgumentInReturnType);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<
- Message Function(DartType _type, DartType _type2, String name,
- String name2, bool isNonNullableByDefault)>
- codeIncorrectTypeArgumentInReturnType = const Code<
- Message Function(DartType _type, DartType _type2, String name,
- String name2, bool isNonNullableByDefault)>(
- "IncorrectTypeArgumentInReturnType",
- analyzerCodes: <String>["TYPE_ARGUMENT_NOT_MATCHING_BOUNDS"]);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-Message _withArgumentsIncorrectTypeArgumentInReturnType(DartType _type,
- DartType _type2, String name, String name2, bool isNonNullableByDefault) {
- TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
- List<Object> typeParts = labeler.labelType(_type);
- List<Object> type2Parts = labeler.labelType(_type2);
- if (name.isEmpty) throw 'No name provided';
- name = demangleMixinApplicationName(name);
- if (name2.isEmpty) throw 'No name provided';
- name2 = demangleMixinApplicationName(name2);
- String type = typeParts.join();
- String type2 = type2Parts.join();
- return new Message(codeIncorrectTypeArgumentInReturnType,
- problemMessage:
- """Type argument '${type}' doesn't conform to the bound '${type2}' of the type variable '${name}' on '${name2}' in the return type.""" +
- labeler.originMessages,
- correctionMessage: """Try changing type arguments so that they conform to the bounds.""",
- arguments: {
- 'type': _type,
- 'type2': _type2,
- 'name': name,
- 'name2': name2
- });
-}
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Template<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>
- templateIncorrectTypeArgumentInSupertype = const Template<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>(
- problemMessageTemplate:
- r"""Type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the supertype '#name3' of class '#name4'.""",
- correctionMessageTemplate:
- r"""Try changing type arguments so that they conform to the bounds.""",
- withArguments: _withArgumentsIncorrectTypeArgumentInSupertype);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)> codeIncorrectTypeArgumentInSupertype =
- const Code<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>(
- "IncorrectTypeArgumentInSupertype",
- analyzerCodes: <String>["TYPE_ARGUMENT_NOT_MATCHING_BOUNDS"]);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-Message _withArgumentsIncorrectTypeArgumentInSupertype(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault) {
- TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
- List<Object> typeParts = labeler.labelType(_type);
- List<Object> type2Parts = labeler.labelType(_type2);
- if (name.isEmpty) throw 'No name provided';
- name = demangleMixinApplicationName(name);
- if (name2.isEmpty) throw 'No name provided';
- name2 = demangleMixinApplicationName(name2);
- if (name3.isEmpty) throw 'No name provided';
- name3 = demangleMixinApplicationName(name3);
- if (name4.isEmpty) throw 'No name provided';
- name4 = demangleMixinApplicationName(name4);
- String type = typeParts.join();
- String type2 = type2Parts.join();
- return new Message(codeIncorrectTypeArgumentInSupertype,
- problemMessage:
- """Type argument '${type}' doesn't conform to the bound '${type2}' of the type variable '${name}' on '${name2}' in the supertype '${name3}' of class '${name4}'.""" +
- labeler.originMessages,
- correctionMessage:
- """Try changing type arguments so that they conform to the bounds.""",
- arguments: {
- 'type': _type,
- 'type2': _type2,
- 'name': name,
- 'name2': name2,
- 'name3': name3,
- 'name4': name4
- });
-}
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Template<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>
- templateIncorrectTypeArgumentInSupertypeInferred = const Template<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>(
- problemMessageTemplate:
- r"""Inferred type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the supertype '#name3' of class '#name4'.""",
- correctionMessageTemplate:
- r"""Try specifying type arguments explicitly so that they conform to the bounds.""",
- withArguments: _withArgumentsIncorrectTypeArgumentInSupertypeInferred);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>
- codeIncorrectTypeArgumentInSupertypeInferred = const Code<
- Message Function(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault)>(
- "IncorrectTypeArgumentInSupertypeInferred",
- analyzerCodes: <String>["TYPE_ARGUMENT_NOT_MATCHING_BOUNDS"]);
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-Message _withArgumentsIncorrectTypeArgumentInSupertypeInferred(
- DartType _type,
- DartType _type2,
- String name,
- String name2,
- String name3,
- String name4,
- bool isNonNullableByDefault) {
- TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
- List<Object> typeParts = labeler.labelType(_type);
- List<Object> type2Parts = labeler.labelType(_type2);
- if (name.isEmpty) throw 'No name provided';
- name = demangleMixinApplicationName(name);
- if (name2.isEmpty) throw 'No name provided';
- name2 = demangleMixinApplicationName(name2);
- if (name3.isEmpty) throw 'No name provided';
- name3 = demangleMixinApplicationName(name3);
- if (name4.isEmpty) throw 'No name provided';
- name4 = demangleMixinApplicationName(name4);
- String type = typeParts.join();
- String type2 = type2Parts.join();
- return new Message(codeIncorrectTypeArgumentInSupertypeInferred,
- problemMessage:
- """Inferred type argument '${type}' doesn't conform to the bound '${type2}' of the type variable '${name}' on '${name2}' in the supertype '${name3}' of class '${name4}'.""" +
- labeler.originMessages,
- correctionMessage:
- """Try specifying type arguments explicitly so that they conform to the bounds.""",
- arguments: {
- 'type': _type,
- 'type2': _type2,
- 'name': name,
- 'name2': name2,
- 'name3': name3,
- 'name4': name4
- });
-}
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Template<
- Message Function(DartType _type, DartType _type2, String name,
- String name2, bool isNonNullableByDefault)>
templateIncorrectTypeArgumentInferred = const Template<
Message Function(DartType _type, DartType _type2, String name,
String name2, bool isNonNullableByDefault)>(
diff --git a/pkg/front_end/lib/src/fasta/incremental_compiler.dart b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
index e193567..ef54d70 100644
--- a/pkg/front_end/lib/src/fasta/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
@@ -135,6 +135,8 @@
import 'util/textual_outline.dart' show textualOutline;
+import 'uris.dart' show dartCore;
+
import 'hybrid_file_system.dart' show HybridFileSystem;
import 'kernel/hierarchy/hierarchy_builder.dart' show ClassHierarchyBuilder;
@@ -655,7 +657,7 @@
dillLibraryBuilder.exportScope.lookupLocalMember(name, setter: false);
if (dillBuilder == null) {
if ((name == 'dynamic' || name == 'Never') &&
- sourceLibraryBuilder.importUri == Uri.parse('dart:core')) {
+ sourceLibraryBuilder.importUri == dartCore) {
// The source library builder for dart:core has synthetically
// injected builders for `dynamic` and `Never` which do not have
// corresponding classes in the AST.
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index a5fac56..6f25365 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -85,7 +85,7 @@
import '../source/source_factory_builder.dart';
import '../source/source_field_builder.dart';
import '../source/source_function_builder.dart';
-import '../source/source_library_builder.dart' show SourceLibraryBuilder;
+import '../source/source_library_builder.dart';
import '../source/source_procedure_builder.dart';
import '../source/stack_listener_impl.dart'
show StackListenerImpl, offsetForToken;
@@ -1010,7 +1010,8 @@
// `invalid-type`.
TypeBuilder? type = pop() as TypeBuilder?;
if (type != null) {
- buildDartType(type, allowPotentiallyConstantType: false);
+ buildDartType(type, TypeUse.fieldType,
+ allowPotentiallyConstantType: false);
}
}
pop(); // Annotations.
@@ -1030,7 +1031,7 @@
_unaliasTypeAliasedConstructorInvocations();
_unaliasTypeAliasedFactoryInvocations(typeAliasedFactoryInvocations);
_resolveRedirectingFactoryTargets(redirectingFactoryInvocations);
- libraryBuilder.checkUncheckedTypedefTypes(typeEnvironment);
+ libraryBuilder.checkPendingBoundsChecks(typeEnvironment);
if (hasDelayedActions) {
assert(
delayedActionPerformers != null,
@@ -2193,7 +2194,7 @@
assert(forest.argumentsTypeArguments(arguments).isEmpty);
forest.argumentsSetTypeArguments(
arguments,
- buildDartTypeArguments(typeArguments,
+ buildDartTypeArguments(typeArguments, TypeUse.invocationTypeArgument,
allowPotentiallyConstantType: false));
} else {
assert(typeArguments == null ||
@@ -3280,8 +3281,6 @@
..fileOffset = identifier.charOffset
..fileEqualsOffset = offsetForToken(equalsToken);
typeInferrer.assignedVariables.declare(variable);
- libraryBuilder.checkBoundsInVariableDeclaration(
- variable, typeEnvironment, uri);
push(variable);
}
@@ -3363,7 +3362,8 @@
}
TypeBuilder? unresolvedType = pop(NullValue.TypeBuilder) as TypeBuilder?;
DartType? type = unresolvedType != null
- ? buildDartType(unresolvedType, allowPotentiallyConstantType: false)
+ ? buildDartType(unresolvedType, TypeUse.variableType,
+ allowPotentiallyConstantType: false)
: null;
int modifiers = (lateToken != null ? lateMask : 0) |
Modifier.validateVarFinalOrConst(varFinalOrConst?.lexeme);
@@ -3805,7 +3805,8 @@
lengthOfSpan(leftBracket, leftBracket.endGroup));
typeArgument = const InvalidType();
} else {
- typeArgument = buildDartType(typeArguments.single,
+ typeArgument = buildDartType(
+ typeArguments.single, TypeUse.literalTypeArgument,
allowPotentiallyConstantType: false);
typeArgument = instantiateToBounds(
typeArgument, coreTypes.objectClass, libraryBuilder.library);
@@ -3822,7 +3823,6 @@
expressions,
isConst: constKeyword != null ||
constantContext == ConstantContext.inferred);
- libraryBuilder.checkBoundsInListLiteral(node, typeEnvironment, uri);
push(node);
}
@@ -3830,7 +3830,8 @@
Token leftBrace, List<dynamic>? setOrMapEntries) {
DartType typeArgument;
if (typeArguments != null) {
- typeArgument = buildDartType(typeArguments.single,
+ typeArgument = buildDartType(
+ typeArguments.single, TypeUse.literalTypeArgument,
allowPotentiallyConstantType: false);
typeArgument = instantiateToBounds(
typeArgument, coreTypes.objectClass, libraryBuilder.library);
@@ -3861,7 +3862,6 @@
expressions,
isConst: constKeyword != null ||
constantContext == ConstantContext.inferred);
- libraryBuilder.checkBoundsInSetLiteral(node, typeEnvironment, uri);
push(node);
}
@@ -3971,9 +3971,9 @@
keyType = const InvalidType();
valueType = const InvalidType();
} else {
- keyType = buildDartType(typeArguments[0],
+ keyType = buildDartType(typeArguments[0], TypeUse.literalTypeArgument,
allowPotentiallyConstantType: false);
- valueType = buildDartType(typeArguments[1],
+ valueType = buildDartType(typeArguments[1], TypeUse.literalTypeArgument,
allowPotentiallyConstantType: false);
keyType = instantiateToBounds(
keyType, coreTypes.objectClass, libraryBuilder.library);
@@ -3995,7 +3995,6 @@
entries,
isConst: constKeyword != null ||
constantContext == ConstantContext.inferred);
- libraryBuilder.checkBoundsInMapLiteral(node, typeEnvironment, uri);
push(node);
}
@@ -4222,10 +4221,8 @@
@override
void handleAsOperator(Token operator) {
debugEvent("AsOperator");
- DartType type = buildDartType(pop() as TypeBuilder,
+ DartType type = buildDartType(pop() as TypeBuilder, TypeUse.asType,
allowPotentiallyConstantType: libraryBuilder.isNonNullableByDefault);
- libraryBuilder.checkBoundsInType(
- type, typeEnvironment, uri, operator.charOffset);
Expression expression = popForValue();
Expression asExpression = forest.createAsExpression(
offsetForToken(operator), expression, type,
@@ -4246,15 +4243,13 @@
@override
void handleIsOperator(Token isOperator, Token? not) {
debugEvent("IsOperator");
- DartType type = buildDartType(pop() as TypeBuilder,
+ DartType type = buildDartType(pop() as TypeBuilder, TypeUse.isType,
allowPotentiallyConstantType: libraryBuilder.isNonNullableByDefault);
Expression operand = popForValue();
Expression isExpression = forest.createIsExpression(
offsetForToken(isOperator), operand, type,
forNonNullableByDefault: libraryBuilder.isNonNullableByDefault,
notFileOffset: not != null ? offsetForToken(not) : null);
- libraryBuilder.checkBoundsInType(
- type, typeEnvironment, uri, isOperator.charOffset);
push(isExpression);
}
@@ -4351,16 +4346,6 @@
}
Object? nameNode = pop();
TypeBuilder? type = pop() as TypeBuilder?;
- if (functionNestingLevel == 0 && type != null) {
- // TODO(ahe): The type we compute here may be different from what is
- // computed in the outline phase. We should make sure that the outline
- // phase computes the same type. See
- // pkg/front_end/testcases/deferred_type_annotation.dart for an example
- // where not calling [buildDartType] leads to a missing compile-time
- // error. Also, notice that the type of the problematic parameter isn't
- // `invalid-type`.
- buildDartType(type, allowPotentiallyConstantType: false);
- }
Token? varOrFinalOrConst = pop(NullValue.Token) as Token?;
if (superKeyword != null &&
varOrFinalOrConst != null &&
@@ -4569,7 +4554,7 @@
popIfNotNull(onKeyword) as TypeBuilder?;
DartType exceptionType;
if (unresolvedExceptionType != null) {
- exceptionType = buildDartType(unresolvedExceptionType,
+ exceptionType = buildDartType(unresolvedExceptionType, TypeUse.catchType,
allowPotentiallyConstantType: false);
} else {
exceptionType = (libraryBuilder.isNonNullableByDefault
@@ -5285,7 +5270,7 @@
receiver = forest.createInstantiation(
instantiationOffset,
receiver,
- buildDartTypeArguments(typeArguments,
+ buildDartTypeArguments(typeArguments, TypeUse.tearOffTypeArgument,
allowPotentiallyConstantType: true));
}
return forest.createMethodInvocation(invocationOffset, receiver,
@@ -5295,7 +5280,8 @@
assert(forest.argumentsTypeArguments(arguments).isEmpty);
forest.argumentsSetTypeArguments(
arguments,
- buildDartTypeArguments(typeArguments,
+ buildDartTypeArguments(
+ typeArguments, TypeUse.constructorTypeArgument,
allowPotentiallyConstantType: false));
}
return buildUnresolvedError(
@@ -5437,7 +5423,8 @@
}
List<DartType> dartTypeArguments = [];
for (TypeBuilder typeBuilder in unaliasedTypeArgumentBuilders) {
- dartTypeArguments.add(typeBuilder.build(libraryBuilder));
+ dartTypeArguments.add(typeBuilder.build(
+ libraryBuilder, TypeUse.constructorTypeArgument));
}
assert(forest.argumentsTypeArguments(arguments).isEmpty);
forest.argumentsSetTypeArguments(arguments, dartTypeArguments);
@@ -5452,8 +5439,8 @@
typeArgumentBuilders.length, const DynamicType(),
growable: false);
for (int i = 0; i < typeArgumentsToCheck.length; ++i) {
- typeArgumentsToCheck[i] =
- typeArgumentBuilders[i].build(libraryBuilder);
+ typeArgumentsToCheck[i] = typeArgumentBuilders[i]
+ .build(libraryBuilder, TypeUse.constructorTypeArgument);
}
}
DartType typeToCheck = new TypedefType(
@@ -5491,7 +5478,8 @@
}
List<DartType> dartTypeArguments = [];
for (TypeBuilder typeBuilder in unaliasedTypeArgumentBuilders) {
- dartTypeArguments.add(typeBuilder.build(libraryBuilder));
+ dartTypeArguments.add(typeBuilder.build(
+ libraryBuilder, TypeUse.constructorTypeArgument));
}
assert(forest.argumentsTypeArguments(arguments).isEmpty);
forest.argumentsSetTypeArguments(arguments, dartTypeArguments);
@@ -5505,8 +5493,8 @@
// No type arguments provided to unaliased class, use defaults.
List<DartType> result = new List<DartType>.generate(
cls.typeVariables!.length,
- (int i) => cls.typeVariables![i].defaultType!
- .build(cls.libraryBuilder),
+ (int i) => cls.typeVariables![i].defaultType!.build(
+ cls.libraryBuilder, TypeUse.constructorTypeArgument),
growable: true);
forest.argumentsSetTypeArguments(arguments, result);
}
@@ -5518,7 +5506,8 @@
assert(forest.argumentsTypeArguments(arguments).isEmpty);
forest.argumentsSetTypeArguments(
arguments,
- buildDartTypeArguments(typeArguments,
+ buildDartTypeArguments(
+ typeArguments, TypeUse.constructorTypeArgument,
allowPotentiallyConstantType: false));
}
}
@@ -7195,7 +7184,7 @@
} else {
push(new Instantiation(
toValue(operand),
- buildDartTypeArguments(typeArguments,
+ buildDartTypeArguments(typeArguments, TypeUse.tearOffTypeArgument,
allowPotentiallyConstantType: true))
..fileOffset = openAngleBracket.charOffset);
}
@@ -7425,20 +7414,28 @@
}
@override
- DartType buildDartType(TypeBuilder typeBuilder,
+ DartType buildDartType(TypeBuilder typeBuilder, TypeUse typeUse,
{required bool allowPotentiallyConstantType}) {
return validateTypeVariableUse(typeBuilder,
allowPotentiallyConstantType: allowPotentiallyConstantType)
- .build(libraryBuilder);
+ .build(libraryBuilder, typeUse);
+ }
+
+ DartType buildAliasedDartType(TypeBuilder typeBuilder, TypeUse typeUse,
+ {required bool allowPotentiallyConstantType}) {
+ return validateTypeVariableUse(typeBuilder,
+ allowPotentiallyConstantType: allowPotentiallyConstantType)
+ .buildAliased(libraryBuilder, typeUse);
}
@override
- List<DartType> buildDartTypeArguments(List<TypeBuilder>? unresolvedTypes,
+ List<DartType> buildDartTypeArguments(
+ List<TypeBuilder>? unresolvedTypes, TypeUse typeUse,
{required bool allowPotentiallyConstantType}) {
if (unresolvedTypes == null) return <DartType>[];
return new List<DartType>.generate(
unresolvedTypes.length,
- (int i) => buildDartType(unresolvedTypes[i],
+ (int i) => buildDartType(unresolvedTypes[i], typeUse,
allowPotentiallyConstantType: allowPotentiallyConstantType),
growable: true);
}
@@ -7652,9 +7649,12 @@
AsyncMarker asyncModifier,
Statement body,
int fileEndOffset) {
+ // TODO(johnniwinther): Avoid creating a FunctionTypeBuilder to create
+ // the function. The function type is not written as a type by the user
+ // and shouldn't be checked as such.
FunctionType type = toFunctionType(
returnType, const NullabilityBuilder.omitted(), typeParameters)
- .build(library) as FunctionType;
+ .build(library, TypeUse.functionSignature) as FunctionType;
List<VariableDeclaration> positionalParameters = <VariableDeclaration>[];
List<VariableDeclaration> namedParameters = <VariableDeclaration>[];
if (parameters != null) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
index 927fca16..4d0d98c 100644
--- a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
@@ -11,6 +11,7 @@
import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token;
import 'package:kernel/ast.dart';
+import 'package:kernel/src/unaliasing.dart';
import 'package:kernel/text/ast_to_text.dart';
import 'package:kernel/type_algebra.dart';
@@ -56,7 +57,6 @@
import '../scope.dart';
-import '../source/source_library_builder.dart';
import '../source/stack_listener_impl.dart' show offsetForToken;
import 'body_builder.dart' show noLocation;
@@ -261,7 +261,8 @@
int fileOffset, List<TypeBuilder>? typeArguments) {
return new Instantiation(
buildSimpleRead(),
- _helper.buildDartTypeArguments(typeArguments,
+ _helper.buildDartTypeArguments(
+ typeArguments, TypeUse.tearOffTypeArgument,
allowPotentiallyConstantType: true))
..fileOffset = fileOffset;
}
@@ -2920,7 +2921,7 @@
int charOffset = offsetForToken(prefixGenerator.token);
message = templateDeferredTypeAnnotation
.withArguments(
- _helper.buildDartType(type,
+ _helper.buildDartType(type, TypeUse.deferredTypeError,
allowPotentiallyConstantType: allowPotentiallyConstantType),
prefixGenerator._plainNameForRead,
_helper.libraryBuilder.isNonNullableByDefault)
@@ -3084,6 +3085,7 @@
buildTypeWithResolvedArguments(
_helper.libraryBuilder.nonNullableBuilder, typeArguments,
allowPotentiallyConstantType: true, forTypeLiteral: true),
+ TypeUse.typeLiteral,
allowPotentiallyConstantType:
_helper.libraryFeatures.constructorTearoffs.isEnabled));
}
@@ -3127,14 +3129,15 @@
} else {
if (declarationBuilder is DeclarationBuilder) {
if (aliasedTypeArguments != null) {
- _helper.libraryBuilder.uncheckedTypedefTypes.add(
- new UncheckedTypedefType(new TypedefType(
- aliasBuilder.typedef,
- _helper.libraryBuilder.nonNullable,
- aliasBuilder.buildTypeArguments(
- _helper.libraryBuilder, aliasedTypeArguments)))
- ..fileUri = _uri
- ..offset = fileOffset);
+ new NamedTypeBuilder(
+ aliasBuilder.name, const NullabilityBuilder.omitted(),
+ arguments: aliasedTypeArguments,
+ fileUri: _uri,
+ charOffset: fileOffset,
+ instanceTypeVariableAccess:
+ _helper.instanceTypeVariableAccessState)
+ ..bind(_helper.libraryBuilder, aliasBuilder)
+ ..build(_helper.libraryBuilder, TypeUse.instantiation);
}
// If the arguments weren't supplied, the tear off is treated as
@@ -3225,12 +3228,15 @@
builtTypeArguments.add(typeParameter.defaultType);
}
} else {
- builtTypeArguments = declarationBuilder.buildTypeArguments(
- _helper.libraryBuilder, unaliasedTypeArguments);
+ builtTypeArguments = unaliasTypes(
+ declarationBuilder.buildAliasedTypeArguments(
+ _helper.libraryBuilder, unaliasedTypeArguments),
+ legacyEraseAliases:
+ !_helper.libraryBuilder.isNonNullableByDefault)!;
}
} else if (typeArguments != null) {
builtTypeArguments = _helper.buildDartTypeArguments(
- typeArguments,
+ typeArguments, TypeUse.tearOffTypeArgument,
allowPotentiallyConstantType: true);
}
if (isGenericTypedefTearOff) {
@@ -3262,6 +3268,10 @@
.add(freshTypeParameters.substitute(builtTypeArgument));
}
}
+ substitutedTypeArguments = unaliasTypes(
+ substitutedTypeArguments,
+ legacyEraseAliases:
+ !_helper.libraryBuilder.isNonNullableByDefault);
tearOffExpression = _helper.forest.createTypedefTearOff(
token.charOffset,
@@ -3271,6 +3281,10 @@
} else {
if (builtTypeArguments != null &&
builtTypeArguments.isNotEmpty) {
+ builtTypeArguments = unaliasTypes(builtTypeArguments,
+ legacyEraseAliases:
+ !_helper.libraryBuilder.isNonNullableByDefault)!;
+
tearOffExpression = _helper.forest.createInstantiation(
token.charOffset, tearOffExpression, builtTypeArguments);
}
@@ -3672,7 +3686,8 @@
assert(_forest.argumentsTypeArguments(arguments).isEmpty);
_forest.argumentsSetTypeArguments(
arguments,
- _helper.buildDartTypeArguments(typeArguments,
+ _helper.buildDartTypeArguments(
+ typeArguments, TypeUse.constructorTypeArgument,
allowPotentiallyConstantType: false));
}
return buildError(arguments, kind: UnresolvedKind.Constructor);
diff --git a/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart b/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
index 41ab864..b10a3ff 100644
--- a/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/expression_generator_helper.dart
@@ -150,10 +150,11 @@
Expression evaluateArgumentsBefore(
Arguments arguments, Expression expression);
- DartType buildDartType(TypeBuilder typeBuilder,
+ DartType buildDartType(TypeBuilder typeBuilder, TypeUse typeUse,
{required bool allowPotentiallyConstantType});
- List<DartType> buildDartTypeArguments(List<TypeBuilder>? typeArguments,
+ List<DartType> buildDartTypeArguments(
+ List<TypeBuilder>? typeArguments, TypeUse typeUse,
{required bool allowPotentiallyConstantType});
void reportDuplicatedDeclaration(
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 6debbc9..dd68ba0 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -18,7 +18,7 @@
import '../fasta_codes.dart';
import '../names.dart';
import '../problems.dart' show unhandled;
-import '../source/source_library_builder.dart' show SourceLibraryBuilder;
+import '../source/source_library_builder.dart';
import '../type_inference/type_constraint_gatherer.dart';
import '../type_inference/type_inference_engine.dart';
import '../type_inference/type_inferrer.dart';
@@ -274,8 +274,7 @@
resultType.returnType, resultType.declaredNullability,
namedParameters: resultType.namedParameters,
typeParameters: freshTypeParameters.freshTypeParameters,
- requiredParameterCount: resultType.requiredParameterCount,
- typedefType: null);
+ requiredParameterCount: resultType.requiredParameterCount);
ExpressionInferenceResult inferredResult =
inferrer.instantiateTearOff(resultType, typeContext, node);
return inferrer.ensureAssignableResult(typeContext, inferredResult);
@@ -1397,8 +1396,6 @@
inferrer.dataForTesting!.typeInferenceResult.inferredVariableTypes[node] =
inferredType.returnType;
}
- inferrer.libraryBuilder.checkBoundsInFunctionNode(node.function,
- inferrer.typeSchemaEnvironment, inferrer.libraryBuilder.fileUri);
node.variable.type = inferredType;
inferrer.flowAnalysis.functionExpression_end();
return const StatementInferenceResult();
@@ -1414,11 +1411,6 @@
inferrer.dataForTesting!.typeInferenceResult.inferredVariableTypes[node] =
inferredType.returnType;
}
- // In anonymous functions the return type isn't declared, so
- // it shouldn't be checked.
- inferrer.libraryBuilder.checkBoundsInFunctionNode(node.function,
- inferrer.typeSchemaEnvironment, inferrer.libraryBuilder.fileUri,
- skipReturnType: true);
inferrer.flowAnalysis.functionExpression_end();
return new ExpressionInferenceResult(inferredType, node);
}
@@ -2088,9 +2080,10 @@
if (!inferrer.isTopLevel) {
SourceLibraryBuilder library = inferrer.libraryBuilder;
if (inferenceNeeded) {
- library.checkBoundsInListLiteral(
- node, inferrer.typeSchemaEnvironment, inferrer.helper!.uri,
- inferred: true);
+ if (!library.libraryFeatures.genericMetadata.isEnabled) {
+ inferrer.checkGenericFunctionTypeArgument(
+ node.typeArgument, node.fileOffset);
+ }
}
}
@@ -2885,9 +2878,12 @@
// Either both [_declaredKeyType] and [_declaredValueType] are omitted or
// none of them, so we may just check one.
if (inferenceNeeded) {
- library.checkBoundsInMapLiteral(
- node, inferrer.typeSchemaEnvironment, inferrer.helper!.uri,
- inferred: true);
+ if (!library.libraryFeatures.genericMetadata.isEnabled) {
+ inferrer.checkGenericFunctionTypeArgument(
+ node.keyType, node.fileOffset);
+ inferrer.checkGenericFunctionTypeArgument(
+ node.valueType, node.fileOffset);
+ }
}
}
return new ExpressionInferenceResult(inferredType, node);
@@ -6032,9 +6028,10 @@
if (!inferrer.isTopLevel) {
SourceLibraryBuilder library = inferrer.libraryBuilder;
if (inferenceNeeded) {
- library.checkBoundsInSetLiteral(
- node, inferrer.typeSchemaEnvironment, inferrer.helper!.uri,
- inferred: true);
+ if (!library.libraryFeatures.genericMetadata.isEnabled) {
+ inferrer.checkGenericFunctionTypeArgument(
+ node.typeArgument, node.fileOffset);
+ }
}
if (!library.loader.target.backendTarget.supportsSetLiterals) {
@@ -6453,13 +6450,6 @@
TypeLiteral node, DartType typeContext) {
DartType inferredType =
inferrer.coreTypes.typeRawType(inferrer.libraryBuilder.nonNullable);
- if (inferrer.libraryFeatures.constructorTearoffs.isEnabled) {
- inferrer.libraryBuilder.checkBoundsInType(
- node.type,
- inferrer.typeSchemaEnvironment,
- inferrer.libraryBuilder.fileUri,
- node.fileOffset);
- }
return new ExpressionInferenceResult(inferredType, node);
}
@@ -6592,14 +6582,6 @@
Expression initializer = initializerResult.expression;
node.initializer = initializer..parent = node;
}
- if (!inferrer.isTopLevel) {
- SourceLibraryBuilder library = inferrer.libraryBuilder;
- if (node.isImplicitlyTyped) {
- library.checkBoundsInVariableDeclaration(
- node, inferrer.typeSchemaEnvironment, inferrer.helper!.uri,
- inferred: true);
- }
- }
if (node.isLate &&
inferrer.libraryBuilder.loader.target.backendTarget
.isLateLocalLoweringEnabled(
diff --git a/pkg/front_end/lib/src/fasta/kernel/invalid_type.dart b/pkg/front_end/lib/src/fasta/kernel/invalid_type.dart
index 0d49a4e..c2759d1 100644
--- a/pkg/front_end/lib/src/fasta/kernel/invalid_type.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/invalid_type.dart
@@ -89,9 +89,6 @@
for (NamedType parameter in node.namedParameters) {
if (parameter.type.accept1(this, visitedTypedefs)) return true;
}
- if (node.typedefType != null && visitedTypedefs.add(node.typedefType!)) {
- if (node.typedefType!.accept1(this, visitedTypedefs)) return true;
- }
return false;
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/macro/identifiers.dart b/pkg/front_end/lib/src/fasta/kernel/macro/identifiers.dart
index 1ecd8aa..75daa98 100644
--- a/pkg/front_end/lib/src/fasta/kernel/macro/identifiers.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/macro/identifiers.dart
@@ -16,6 +16,7 @@
import '../../builder/type_alias_builder.dart';
import '../../builder/type_builder.dart';
import '../../builder/type_declaration_builder.dart';
+import '../../uris.dart';
import 'macro.dart';
abstract class IdentifierImpl extends macro.IdentifierImpl {
@@ -41,7 +42,7 @@
} else if (typeDeclarationBuilder is TypeAliasBuilder) {
uri = typeDeclarationBuilder.libraryBuilder.importUri;
} else if (name == 'dynamic') {
- uri = Uri.parse('dart:core');
+ uri = dartCore;
}
return new macro.ResolvedIdentifier(
kind: macro.IdentifierKind.topLevelMember,
@@ -88,8 +89,16 @@
@override
DartType buildType(
NullabilityBuilder nullabilityBuilder, List<DartType> typeArguments) {
- return typeBuilder.declaration!.buildTypeWithBuiltArguments(libraryBuilder,
- nullabilityBuilder.build(libraryBuilder), typeArguments);
+ return typeBuilder.declaration!.buildAliasedTypeWithBuiltArguments(
+ libraryBuilder,
+ nullabilityBuilder.build(libraryBuilder),
+ typeArguments,
+ TypeUse.macroTypeArgument,
+ // TODO(johnniwinther): How should handle malbounded types here? Should
+ // we report an error on the annotation?
+ missingUri,
+ TreeNode.noOffset,
+ hasExplicitTypeArguments: true);
}
@override
@@ -124,8 +133,16 @@
@override
DartType buildType(
NullabilityBuilder nullabilityBuilder, List<DartType> typeArguments) {
- return typeDeclarationBuilder.buildTypeWithBuiltArguments(libraryBuilder,
- nullabilityBuilder.build(libraryBuilder), typeArguments);
+ return typeDeclarationBuilder.buildAliasedTypeWithBuiltArguments(
+ libraryBuilder,
+ nullabilityBuilder.build(libraryBuilder),
+ typeArguments,
+ TypeUse.macroTypeArgument,
+ // TODO(johnniwinther): How should handle malbounded types here? Should
+ // we report an error on the annotation?
+ missingUri,
+ TreeNode.noOffset,
+ hasExplicitTypeArguments: true);
}
}
@@ -219,7 +236,7 @@
kind: macro.IdentifierKind.topLevelMember,
name: name,
staticScope: null,
- uri: Uri.parse('dart:core'));
+ uri: dartCore);
}
@override
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index fda68ec..9039e6a 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -56,7 +56,7 @@
import 'source_constructor_builder.dart';
import 'source_factory_builder.dart';
import 'source_field_builder.dart';
-import 'source_library_builder.dart' show SourceLibraryBuilder;
+import 'source_library_builder.dart';
import 'source_member_builder.dart';
Class initializeClass(
@@ -523,15 +523,22 @@
int get typeVariablesCount => typeVariables?.length ?? 0;
@override
- List<DartType> buildTypeArguments(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments) {
if (arguments == null && typeVariables == null) {
return <DartType>[];
}
if (arguments == null && typeVariables != null) {
- List<DartType> result = new List<DartType>.generate(typeVariables!.length,
- (int i) => typeVariables![i].defaultType!.build(library),
+ // TODO(johnniwinther): Use i2b here when needed.
+ List<DartType> result = new List<DartType>.generate(
+ typeVariables!.length,
+ (int i) => typeVariables![i]
+ .defaultType!
+ // TODO(johnniwinther): Using [libraryBuilder] here instead of
+ // [library] preserves the nullability of the original
+ // declaration. Should we legacy erase this?
+ .buildAliased(libraryBuilder, TypeUse.defaultTypeAsTypeArgument),
growable: true);
if (library is SourceLibraryBuilder) {
library.inferredTypes.addAll(result);
@@ -551,8 +558,8 @@
}
assert(arguments!.length == typeVariablesCount);
- List<DartType> result = new List<DartType>.generate(
- arguments!.length, (int i) => arguments[i].build(library),
+ List<DartType> result = new List<DartType>.generate(arguments!.length,
+ (int i) => arguments[i].buildAliased(library, TypeUse.typeArgument),
growable: true);
return result;
}
@@ -1321,99 +1328,7 @@
}
}
- void checkBoundsInSupertype(
- Supertype supertype, TypeEnvironment typeEnvironment) {
- Library library = libraryBuilder.library;
-
- List<TypeArgumentIssue> issues = findTypeArgumentIssues(
- new InterfaceType(
- supertype.classNode, library.nonNullable, supertype.typeArguments),
- typeEnvironment,
- libraryBuilder.isNonNullableByDefault
- ? SubtypeCheckMode.withNullabilities
- : SubtypeCheckMode.ignoringNullabilities,
- allowSuperBounded: false,
- isNonNullableByDefault: library.isNonNullableByDefault,
- areGenericArgumentsAllowed:
- libraryBuilder.libraryFeatures.genericMetadata.isEnabled);
- for (TypeArgumentIssue issue in issues) {
- DartType argument = issue.argument;
- TypeParameter typeParameter = issue.typeParameter;
- bool inferred = libraryBuilder.inferredTypes.contains(argument);
- if (issue.isGenericTypeAsArgumentIssue) {
- if (inferred) {
- // Supertype can't be or contain super-bounded types, so null is
- // passed for super-bounded hint here.
- libraryBuilder.reportTypeArgumentIssue(
- templateGenericFunctionTypeInferredAsActualTypeArgument
- .withArguments(argument, library.isNonNullableByDefault),
- fileUri,
- charOffset,
- typeParameter: null,
- superBoundedAttempt: null,
- superBoundedAttemptInverted: null);
- } else {
- // Supertype can't be or contain super-bounded types, so null is
- // passed for super-bounded hint here.
- libraryBuilder.reportTypeArgumentIssue(
- messageGenericFunctionTypeUsedAsActualTypeArgument,
- fileUri,
- charOffset,
- typeParameter: null,
- superBoundedAttempt: null,
- superBoundedAttemptInverted: null);
- }
- } else {
- void reportProblem(
- Template<
- Message Function(DartType, DartType, String, String, String,
- String, bool)>
- template) {
- // Supertype can't be or contain super-bounded types, so null is
- // passed for super-bounded hint here.
- libraryBuilder.reportTypeArgumentIssue(
- template.withArguments(
- argument,
- typeParameter.bound,
- typeParameter.name!,
- getGenericTypeName(issue.enclosingType!),
- supertype.classNode.name,
- name,
- library.isNonNullableByDefault),
- fileUri,
- charOffset,
- typeParameter: typeParameter,
- superBoundedAttempt: null,
- superBoundedAttemptInverted: null);
- }
-
- if (inferred) {
- reportProblem(templateIncorrectTypeArgumentInSupertypeInferred);
- } else {
- reportProblem(templateIncorrectTypeArgumentInSupertype);
- }
- }
- }
- }
-
void checkTypesInOutline(TypeEnvironment typeEnvironment) {
- libraryBuilder.checkBoundsInTypeParameters(
- typeEnvironment, cls.typeParameters, fileUri);
-
- // Check in supers.
- if (cls.supertype != null) {
- checkBoundsInSupertype(cls.supertype!, typeEnvironment);
- }
- if (cls.mixedInType != null) {
- checkBoundsInSupertype(cls.mixedInType!, typeEnvironment);
- }
- // ignore: unnecessary_null_comparison
- if (cls.implementedTypes != null) {
- for (Supertype supertype in cls.implementedTypes) {
- checkBoundsInSupertype(supertype, typeEnvironment);
- }
- }
-
forEach((String name, Builder builder) {
if (builder is SourceMemberBuilder) {
builder.checkVariance(this, typeEnvironment);
diff --git a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
index 10a8838..f2812d0 100644
--- a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
@@ -179,7 +179,9 @@
List<SourceFieldBuilder> elementBuilders = <SourceFieldBuilder>[];
NamedTypeBuilder selfType = new NamedTypeBuilder(
name, const NullabilityBuilder.omitted(),
- instanceTypeVariableAccess: InstanceTypeVariableAccessState.Unexpected);
+ instanceTypeVariableAccess: InstanceTypeVariableAccessState.Unexpected,
+ fileUri: fileUri,
+ charOffset: charOffset);
NamedTypeBuilder listType = new NamedTypeBuilder(
"List", const NullabilityBuilder.omitted(),
arguments: <TypeBuilder>[selfType],
@@ -628,7 +630,8 @@
}
DartType buildElement(SourceFieldBuilder fieldBuilder, CoreTypes coreTypes) {
- DartType selfType = this.selfType.build(libraryBuilder);
+ DartType selfType =
+ this.selfType.build(libraryBuilder, TypeUse.enumSelfType);
Builder? builder = firstMemberNamed(fieldBuilder.name);
if (builder == null || !builder.isField) return selfType;
fieldBuilder = builder as SourceFieldBuilder;
@@ -674,7 +677,8 @@
if (typeArgumentBuilders != null) {
typeArguments = <DartType>[];
for (TypeBuilder typeBuilder in typeArgumentBuilders) {
- typeArguments.add(typeBuilder.build(libraryBuilder));
+ typeArguments.add(
+ typeBuilder.build(libraryBuilder, TypeUse.constructorTypeArgument));
}
}
if (libraryBuilder.libraryFeatures.enhancedEnums.isEnabled) {
diff --git a/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart b/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
index 740f9b8..578747e 100644
--- a/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_extension_builder.dart
@@ -91,7 +91,7 @@
/// library.
Extension build(LibraryBuilder coreLibrary,
{required bool addMembersToLibrary}) {
- _extension.onType = onType.build(libraryBuilder);
+ _extension.onType = onType.build(libraryBuilder, TypeUse.extensionOnType);
extensionTypeShowHideClauseBuilder.buildAndStoreTypes(
_extension, libraryBuilder);
@@ -242,16 +242,6 @@
}
void checkTypesInOutline(TypeEnvironment typeEnvironment) {
- libraryBuilder.checkBoundsInTypeParameters(
- typeEnvironment, extension.typeParameters, fileUri);
-
- // Check on clause.
- // ignore: unnecessary_null_comparison
- if (_extension.onType != null) {
- libraryBuilder.checkBoundsInType(_extension.onType, typeEnvironment,
- onType.fileUri!, onType.charOffset!);
- }
-
forEach((String name, Builder builder) {
if (builder is SourceFieldBuilder) {
// Check fields.
diff --git a/pkg/front_end/lib/src/fasta/source/source_factory_builder.dart b/pkg/front_end/lib/src/fasta/source/source_factory_builder.dart
index 09523b6..7ba09c8 100644
--- a/pkg/front_end/lib/src/fasta/source/source_factory_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_factory_builder.dart
@@ -360,7 +360,8 @@
if (redirectionTarget.typeArguments != null) {
typeArguments = new List<DartType>.generate(
redirectionTarget.typeArguments!.length,
- (int i) => redirectionTarget.typeArguments![i].build(libraryBuilder),
+ (int i) => redirectionTarget.typeArguments![i]
+ .build(libraryBuilder, TypeUse.redirectionTypeArgument),
growable: false);
}
updatePrivateMemberName(_procedureInternal, libraryBuilder);
diff --git a/pkg/front_end/lib/src/fasta/source/source_field_builder.dart b/pkg/front_end/lib/src/fasta/source/source_field_builder.dart
index e5d89e8..cdf803a 100644
--- a/pkg/front_end/lib/src/fasta/source/source_field_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_field_builder.dart
@@ -367,7 +367,7 @@
/// Builds the core AST structures for this field as needed for the outline.
void build() {
if (type != null) {
- fieldType = type!.build(libraryBuilder);
+ fieldType = type!.build(libraryBuilder, TypeUse.fieldType);
}
_fieldEncoding.build(libraryBuilder, this);
}
diff --git a/pkg/front_end/lib/src/fasta/source/source_function_builder.dart b/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
index 1411267..e52c631 100644
--- a/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
@@ -387,7 +387,8 @@
function.requiredParameterCount = 1;
}
if (returnType != null) {
- function.returnType = returnType!.build(libraryBuilder);
+ function.returnType =
+ returnType!.build(libraryBuilder, TypeUse.returnType);
}
if (isExtensionInstanceMember) {
ExtensionBuilder extensionBuilder = parent as ExtensionBuilder;
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 53fa58e..963b623 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -21,7 +21,8 @@
TypeArgumentIssue,
findTypeArgumentIssues,
findTypeArgumentIssuesForInvocation,
- getGenericTypeName;
+ getGenericTypeName,
+ hasGenericFunctionTypeAsTypeArgument;
import 'package:kernel/type_algebra.dart' show Substitution, substitute;
import 'package:kernel/type_environment.dart'
show SubtypeCheckMode, TypeEnvironment;
@@ -175,8 +176,8 @@
final List<TypeVariableBuilder> unboundTypeVariables =
<TypeVariableBuilder>[];
- final List<UncheckedTypedefType> uncheckedTypedefTypes =
- <UncheckedTypedefType>[];
+ final List<PendingBoundsCheck> _pendingBoundsChecks = [];
+ final List<GenericFunctionTypeCheck> _pendingGenericFunctionTypeChecks = [];
// A list of alternating forwarders and the procedures they were generated
// for. Note that it may not include a forwarder-origin pair in cases when
@@ -3953,7 +3954,7 @@
addToExportScope(name, member);
}
- void reportTypeArgumentIssues(
+ void _reportTypeArgumentIssues(
Iterable<TypeArgumentIssue> issues, Uri fileUri, int offset,
{bool? inferred,
TypeArgumentsInfo? typeArgumentsInfo,
@@ -4081,11 +4082,6 @@
void checkTypesInField(
SourceFieldBuilder fieldBuilder, TypeEnvironment typeEnvironment) {
- // Check the bounds in the field's type.
- checkBoundsInType(fieldBuilder.fieldType, typeEnvironment,
- fieldBuilder.fileUri, fieldBuilder.charOffset,
- allowSuperBounded: true);
-
// Check that the field has an initializer if its type is potentially
// non-nullable.
if (isNonNullableByDefault) {
@@ -4132,133 +4128,8 @@
}
}
- void checkBoundsInTypeParameters(TypeEnvironment typeEnvironment,
- List<TypeParameter> typeParameters, Uri fileUri) {
- // Check in bounds of own type variables.
- for (TypeParameter parameter in typeParameters) {
- List<TypeArgumentIssue> issues = findTypeArgumentIssues(
- parameter.bound,
- typeEnvironment,
- isNonNullableByDefault
- ? SubtypeCheckMode.withNullabilities
- : SubtypeCheckMode.ignoringNullabilities,
- allowSuperBounded: true,
- isNonNullableByDefault: library.isNonNullableByDefault,
- areGenericArgumentsAllowed:
- libraryFeatures.genericMetadata.isEnabled);
- for (TypeArgumentIssue issue in issues) {
- DartType argument = issue.argument;
- TypeParameter typeParameter = issue.typeParameter;
- if (inferredTypes.contains(argument)) {
- // Inference in type expressions in the supertypes boils down to
- // instantiate-to-bound which shouldn't produce anything that breaks
- // the bounds after the non-simplicity checks are done. So, any
- // violation here is the result of non-simple bounds, and the error
- // is reported elsewhere.
- continue;
- }
-
- if (issue.isGenericTypeAsArgumentIssue) {
- reportTypeArgumentIssue(
- messageGenericFunctionTypeUsedAsActualTypeArgument,
- fileUri,
- parameter.fileOffset,
- typeParameter: null);
- } else {
- reportTypeArgumentIssue(
- templateIncorrectTypeArgument.withArguments(
- argument,
- typeParameter.bound,
- typeParameter.name!,
- getGenericTypeName(issue.enclosingType!),
- library.isNonNullableByDefault),
- fileUri,
- parameter.fileOffset,
- typeParameter: typeParameter,
- superBoundedAttempt: issue.enclosingType,
- superBoundedAttemptInverted: issue.invertedType);
- }
- }
- }
- }
-
- void checkBoundsInFunctionNodeParts(
- TypeEnvironment typeEnvironment, Uri fileUri, int fileOffset,
- {List<TypeParameter>? typeParameters,
- List<VariableDeclaration>? positionalParameters,
- List<VariableDeclaration>? namedParameters,
- DartType? returnType,
- int? requiredParameterCount,
- bool skipReturnType = false}) {
- if (typeParameters != null) {
- for (TypeParameter parameter in typeParameters) {
- checkBoundsInType(
- parameter.bound, typeEnvironment, fileUri, parameter.fileOffset,
- allowSuperBounded: true);
- }
- }
- if (positionalParameters != null) {
- for (int i = 0; i < positionalParameters.length; ++i) {
- VariableDeclaration parameter = positionalParameters[i];
- checkBoundsInType(
- parameter.type, typeEnvironment, fileUri, parameter.fileOffset,
- allowSuperBounded: true);
- }
- }
- if (namedParameters != null) {
- for (int i = 0; i < namedParameters.length; ++i) {
- VariableDeclaration named = namedParameters[i];
- checkBoundsInType(
- named.type, typeEnvironment, fileUri, named.fileOffset,
- allowSuperBounded: true);
- }
- }
- if (!skipReturnType && returnType != null) {
- List<TypeArgumentIssue> issues = findTypeArgumentIssues(
- returnType,
- typeEnvironment,
- isNonNullableByDefault
- ? SubtypeCheckMode.withNullabilities
- : SubtypeCheckMode.ignoringNullabilities,
- allowSuperBounded: true,
- isNonNullableByDefault: library.isNonNullableByDefault,
- areGenericArgumentsAllowed:
- libraryFeatures.genericMetadata.isEnabled);
- for (TypeArgumentIssue issue in issues) {
- DartType argument = issue.argument;
- TypeParameter typeParameter = issue.typeParameter;
-
- // We don't need to check if [argument] was inferred or specified
- // here, because inference in return types boils down to instantiate-
- // -to-bound, and it can't provide a type that violates the bound.
- if (issue.isGenericTypeAsArgumentIssue) {
- reportTypeArgumentIssue(
- messageGenericFunctionTypeUsedAsActualTypeArgument,
- fileUri,
- fileOffset,
- typeParameter: null);
- } else {
- reportTypeArgumentIssue(
- templateIncorrectTypeArgumentInReturnType.withArguments(
- argument,
- typeParameter.bound,
- typeParameter.name!,
- getGenericTypeName(issue.enclosingType!),
- isNonNullableByDefault),
- fileUri,
- fileOffset,
- typeParameter: typeParameter,
- superBoundedAttempt: issue.enclosingType,
- superBoundedAttemptInverted: issue.invertedType);
- }
- }
- }
- }
-
void checkTypesInFunctionBuilder(
SourceFunctionBuilder procedureBuilder, TypeEnvironment typeEnvironment) {
- checkBoundsInFunctionNode(
- procedureBuilder.function, typeEnvironment, procedureBuilder.fileUri!);
if (procedureBuilder.formals != null &&
!(procedureBuilder.isAbstract || procedureBuilder.isExternal)) {
checkInitializersInFormals(procedureBuilder.formals!, typeEnvironment);
@@ -4268,8 +4139,6 @@
void checkTypesInConstructorBuilder(
DeclaredSourceConstructorBuilder constructorBuilder,
TypeEnvironment typeEnvironment) {
- checkBoundsInFunctionNode(
- constructorBuilder.constructor.function, typeEnvironment, fileUri);
if (!constructorBuilder.isExternal && constructorBuilder.formals != null) {
checkInitializersInFormals(constructorBuilder.formals!, typeEnvironment);
}
@@ -4278,50 +4147,10 @@
void checkTypesInRedirectingFactoryBuilder(
RedirectingFactoryBuilder redirectingFactoryBuilder,
TypeEnvironment typeEnvironment) {
- checkBoundsInFunctionNode(redirectingFactoryBuilder.function,
- typeEnvironment, redirectingFactoryBuilder.fileUri);
// Default values are not required on redirecting factory constructors so
// we don't call [checkInitializersInFormals].
}
- void checkBoundsInFunctionNode(
- FunctionNode function, TypeEnvironment typeEnvironment, Uri fileUri,
- {bool skipReturnType = false}) {
- checkBoundsInFunctionNodeParts(
- typeEnvironment, fileUri, function.fileOffset,
- typeParameters: function.typeParameters,
- positionalParameters: function.positionalParameters,
- namedParameters: function.namedParameters,
- returnType: function.returnType,
- requiredParameterCount: function.requiredParameterCount,
- skipReturnType: skipReturnType);
- }
-
- void checkBoundsInListLiteral(
- ListLiteral node, TypeEnvironment typeEnvironment, Uri fileUri,
- {bool inferred = false}) {
- checkBoundsInType(
- node.typeArgument, typeEnvironment, fileUri, node.fileOffset,
- inferred: inferred, allowSuperBounded: true);
- }
-
- void checkBoundsInSetLiteral(
- SetLiteral node, TypeEnvironment typeEnvironment, Uri fileUri,
- {bool inferred = false}) {
- checkBoundsInType(
- node.typeArgument, typeEnvironment, fileUri, node.fileOffset,
- inferred: inferred, allowSuperBounded: true);
- }
-
- void checkBoundsInMapLiteral(
- MapLiteral node, TypeEnvironment typeEnvironment, Uri fileUri,
- {bool inferred = false}) {
- checkBoundsInType(node.keyType, typeEnvironment, fileUri, node.fileOffset,
- inferred: inferred, allowSuperBounded: true);
- checkBoundsInType(node.valueType, typeEnvironment, fileUri, node.fileOffset,
- inferred: inferred, allowSuperBounded: true);
- }
-
void checkBoundsInType(
DartType type, TypeEnvironment typeEnvironment, Uri fileUri, int offset,
{bool? inferred, bool allowSuperBounded = true}) {
@@ -4334,16 +4163,7 @@
allowSuperBounded: allowSuperBounded,
isNonNullableByDefault: library.isNonNullableByDefault,
areGenericArgumentsAllowed: libraryFeatures.genericMetadata.isEnabled);
- reportTypeArgumentIssues(issues, fileUri, offset, inferred: inferred);
- }
-
- void checkBoundsInVariableDeclaration(
- VariableDeclaration node, TypeEnvironment typeEnvironment, Uri fileUri,
- {bool inferred = false}) {
- // ignore: unnecessary_null_comparison
- if (node.type == null) return;
- checkBoundsInType(node.type, typeEnvironment, fileUri, node.fileOffset,
- inferred: inferred, allowSuperBounded: true);
+ _reportTypeArgumentIssues(issues, fileUri, offset, inferred: inferred);
}
void checkBoundsInConstructorInvocation(
@@ -4408,7 +4228,7 @@
new InterfaceType(klass, klass.enclosingLibrary.nonNullable);
}
String targetName = node.target.name.text;
- reportTypeArgumentIssues(issues, fileUri, node.fileOffset,
+ _reportTypeArgumentIssues(issues, fileUri, node.fileOffset,
typeArgumentsInfo: typeArgumentsInfo,
targetReceiver: targetReceiver,
targetName: targetName);
@@ -4487,7 +4307,7 @@
bottomType,
isNonNullableByDefault: library.isNonNullableByDefault,
areGenericArgumentsAllowed: libraryFeatures.genericMetadata.isEnabled);
- reportTypeArgumentIssues(issues, fileUri, offset,
+ _reportTypeArgumentIssues(issues, fileUri, offset,
typeArgumentsInfo: getTypeArgumentsInfo(arguments),
targetReceiver: receiverType,
targetName: name.text);
@@ -4520,7 +4340,7 @@
bottomType,
isNonNullableByDefault: library.isNonNullableByDefault,
areGenericArgumentsAllowed: libraryFeatures.genericMetadata.isEnabled);
- reportTypeArgumentIssues(issues, fileUri, offset,
+ _reportTypeArgumentIssues(issues, fileUri, offset,
typeArgumentsInfo: getTypeArgumentsInfo(arguments),
// TODO(johnniwinther): Special-case messaging on function type
// invocation to avoid reference to 'call' and use the function type
@@ -4557,7 +4377,7 @@
bottomType,
isNonNullableByDefault: library.isNonNullableByDefault,
areGenericArgumentsAllowed: libraryFeatures.genericMetadata.isEnabled);
- reportTypeArgumentIssues(issues, fileUri, offset,
+ _reportTypeArgumentIssues(issues, fileUri, offset,
targetReceiver: functionType,
typeArgumentsInfo: inferred
? const AllInferredTypeArgumentsInfo()
@@ -4592,7 +4412,7 @@
} else if (declaration is SourceExtensionBuilder) {
declaration.checkTypesInOutline(typeEnvironment);
} else if (declaration is SourceTypeAliasBuilder) {
- declaration.checkTypesInOutline(typeEnvironment);
+ // Do nothing.
} else {
assert(
declaration is! TypeDeclarationBuilder ||
@@ -4601,7 +4421,7 @@
}
}
inferredTypes.clear();
- checkUncheckedTypedefTypes(typeEnvironment);
+ checkPendingBoundsChecks(typeEnvironment);
}
void computeShowHideElements(ClassMembersBuilder membersBuilder) {
@@ -4906,19 +4726,113 @@
return type;
}
- /// Performs delayed bounds checks on [TypedefType]s for the library
- ///
- /// As [TypedefType]s are built, they are eagerly unaliased, making it
- /// impossible to perform the bounds checks on them at the time when the
- /// checks can be done. To perform the checks, [TypedefType]s are added to
- /// [uncheckedTypedefTypes] as they are built. This method performs the
- /// checks and clears the list of the types for the delayed check.
- void checkUncheckedTypedefTypes(TypeEnvironment typeEnvironment) {
- for (UncheckedTypedefType uncheckedTypedefType in uncheckedTypedefTypes) {
- checkBoundsInType(uncheckedTypedefType.typeToCheck, typeEnvironment,
- uncheckedTypedefType.fileUri!, uncheckedTypedefType.offset!);
+ void registerBoundsCheck(
+ DartType type, Uri fileUri, int charOffset, TypeUse typeUse,
+ {required bool inferred}) {
+ _pendingBoundsChecks.add(new PendingBoundsCheck(
+ type, fileUri, charOffset, typeUse,
+ inferred: inferred));
+ }
+
+ void registerGenericFunctionTypeCheck(
+ TypedefType type, Uri fileUri, int charOffset) {
+ _pendingGenericFunctionTypeChecks
+ .add(new GenericFunctionTypeCheck(type, fileUri, charOffset));
+ }
+
+ /// Performs delayed bounds checks.
+ void checkPendingBoundsChecks(TypeEnvironment typeEnvironment) {
+ for (PendingBoundsCheck pendingBoundsCheck in _pendingBoundsChecks) {
+ switch (pendingBoundsCheck.typeUse) {
+ case TypeUse.literalTypeArgument:
+ case TypeUse.variableType:
+ case TypeUse.typeParameterBound:
+ case TypeUse.parameterType:
+ case TypeUse.fieldType:
+ case TypeUse.returnType:
+ case TypeUse.isType:
+ case TypeUse.asType:
+ case TypeUse.catchType:
+ case TypeUse.constructorTypeArgument:
+ case TypeUse.redirectionTypeArgument:
+ case TypeUse.tearOffTypeArgument:
+ case TypeUse.invocationTypeArgument:
+ case TypeUse.typeLiteral:
+ case TypeUse.extensionOnType:
+ case TypeUse.typeArgument:
+ checkBoundsInType(pendingBoundsCheck.type, typeEnvironment,
+ pendingBoundsCheck.fileUri, pendingBoundsCheck.charOffset,
+ inferred: pendingBoundsCheck.inferred, allowSuperBounded: true);
+ break;
+ case TypeUse.typedefAlias:
+ case TypeUse.superType:
+ case TypeUse.mixedInType:
+ checkBoundsInType(pendingBoundsCheck.type, typeEnvironment,
+ pendingBoundsCheck.fileUri, pendingBoundsCheck.charOffset,
+ inferred: pendingBoundsCheck.inferred, allowSuperBounded: false);
+ break;
+ case TypeUse.instantiation:
+ // TODO(johnniwinther): Should we allow super bounded tear offs of
+ // non-proper renames?
+ checkBoundsInType(pendingBoundsCheck.type, typeEnvironment,
+ pendingBoundsCheck.fileUri, pendingBoundsCheck.charOffset,
+ inferred: pendingBoundsCheck.inferred, allowSuperBounded: true);
+ break;
+ case TypeUse.enumSelfType:
+ // TODO(johnniwinther): Check/create this type as regular bounded i2b.
+ /*
+ checkBoundsInType(pendingBoundsCheck.type, typeEnvironment,
+ pendingBoundsCheck.fileUri, pendingBoundsCheck.charOffset,
+ inferred: pendingBoundsCheck.inferred,
+ allowSuperBounded: false);
+ */
+ break;
+ case TypeUse.macroTypeArgument:
+ case TypeUse.typeParameterDefaultType:
+ case TypeUse.defaultTypeAsTypeArgument:
+ case TypeUse.deferredTypeError:
+ case TypeUse.functionSignature:
+ break;
+ }
}
- uncheckedTypedefTypes.clear();
+ _pendingBoundsChecks.clear();
+
+ for (GenericFunctionTypeCheck genericFunctionTypeCheck
+ in _pendingGenericFunctionTypeChecks) {
+ checkGenericFunctionTypeAsTypeArgumentThroughTypedef(
+ genericFunctionTypeCheck.type,
+ genericFunctionTypeCheck.fileUri,
+ genericFunctionTypeCheck.charOffset);
+ }
+ _pendingGenericFunctionTypeChecks.clear();
+ }
+
+ /// Reports an error if [type] contains is a generic function type used as
+ /// a type argument through its alias.
+ ///
+ /// For instance
+ ///
+ /// typedef A = B<void Function<T>(T)>;
+ ///
+ /// here `A` doesn't use a generic function as type argument directly, but
+ /// its unaliased value `B<void Function<T>(T)>` does.
+ ///
+ /// This is used for reporting generic function types used as a type argument,
+ /// which was disallowed before the 'generic-metadata' feature was enabled.
+ void checkGenericFunctionTypeAsTypeArgumentThroughTypedef(
+ TypedefType type, Uri fileUri, int fileOffset) {
+ assert(!libraryFeatures.genericMetadata.isEnabled);
+ if (!hasGenericFunctionTypeAsTypeArgument(type)) {
+ DartType unaliased = type.unalias;
+ if (hasGenericFunctionTypeAsTypeArgument(unaliased)) {
+ addProblem(
+ templateGenericFunctionTypeAsTypeArgumentThroughTypedef
+ .withArguments(unaliased, type, isNonNullableByDefault),
+ fileOffset,
+ noLength,
+ fileUri);
+ }
+ }
}
void installTypedefTearOffs() {
@@ -5459,11 +5373,21 @@
}
}
-class UncheckedTypedefType {
- final TypedefType typeToCheck;
+class PendingBoundsCheck {
+ final DartType type;
+ final Uri fileUri;
+ final int charOffset;
+ final TypeUse typeUse;
+ final bool inferred;
- int? offset;
- Uri? fileUri;
+ PendingBoundsCheck(this.type, this.fileUri, this.charOffset, this.typeUse,
+ {required this.inferred});
+}
- UncheckedTypedefType(this.typeToCheck);
+class GenericFunctionTypeCheck {
+ final TypedefType type;
+ final Uri fileUri;
+ final int charOffset;
+
+ GenericFunctionTypeCheck(this.type, this.fileUri, this.charOffset);
}
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index c98f659..cf387f5 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -84,6 +84,7 @@
import '../type_inference/type_inference_engine.dart';
import '../type_inference/type_inferrer.dart';
import '../util/helpers.dart';
+import '../uris.dart';
import 'diet_listener.dart' show DietListener;
import 'diet_parser.dart' show DietParser, useImplicitCreationExpressionInCfe;
import 'name_scheme.dart';
@@ -717,6 +718,8 @@
List<LocatedMessage>? context,
bool problemOnLibrary: false,
List<Uri>? involvedFiles}) {
+ assert(
+ fileUri != missingUri, "Message unexpectedly reported on missing uri.");
severity ??= message.code.severity;
if (severity == Severity.ignored) return null;
String trace = """
diff --git a/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart b/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
index c24455e..8cf8c31 100644
--- a/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
@@ -6,7 +6,6 @@
import 'package:kernel/ast.dart';
import 'package:kernel/class_hierarchy.dart';
-import 'package:kernel/type_environment.dart';
import '../builder/builder.dart';
import '../builder/class_builder.dart';
@@ -88,7 +87,7 @@
}
Typedef build() {
- typedef.type ??= buildThisType();
+ buildThisType();
TypeBuilder? type = this.type;
if (type is FunctionTypeBuilder ||
@@ -120,38 +119,29 @@
// detect cycles by detecting recursive calls to this method using an
// instance of InvalidType that isn't identical to `const InvalidType()`.
thisType = pendingTypeAliasMarker;
+ DartType builtType = const InvalidType();
TypeBuilder? type = this.type;
// ignore: unnecessary_null_comparison
if (type != null) {
- DartType builtType = type.build(libraryBuilder);
- if (builtType is FunctionType) {
- // Set the `typedefType` if it hasn't already been set. It can already
- // be set if this type alias is an alias of another typedef, in which
- // we use the existing value. For instance
- //
- // typedef void F(); // typedefType will be set to `F`.
- // typedef G = F; // The typedefType has already been set to `F`.
- //
- builtType.typedefType ??= thisTypedefType(typedef, libraryBuilder);
- }
+ builtType = type.build(libraryBuilder, TypeUse.typedefAlias);
// ignore: unnecessary_null_comparison
if (builtType != null) {
if (typeVariables != null) {
for (TypeVariableBuilder tv in typeVariables!) {
// Follow bound in order to find all cycles
- tv.bound?.build(libraryBuilder);
+ tv.bound?.build(libraryBuilder, TypeUse.typeParameterBound);
}
}
if (identical(thisType, cyclicTypeAliasMarker)) {
- return thisType = const InvalidType();
+ builtType = const InvalidType();
} else {
- return thisType = builtType;
+ builtType = builtType;
}
} else {
- return thisType = const InvalidType();
+ builtType = const InvalidType();
}
}
- return thisType = const InvalidType();
+ return thisType = typedef.type ??= builtType;
}
TypedefType thisTypedefType(Typedef typedef, LibraryBuilder clientLibrary) {
@@ -190,15 +180,23 @@
}
@override
- List<DartType> buildTypeArguments(
+ List<DartType> buildAliasedTypeArguments(
LibraryBuilder library, List<TypeBuilder>? arguments) {
if (arguments == null && typeVariables == null) {
return <DartType>[];
}
if (arguments == null && typeVariables != null) {
- List<DartType> result = new List<DartType>.generate(typeVariables!.length,
- (int i) => typeVariables![i].defaultType!.build(library),
+ // TODO(johnniwinther): Use i2b here when needed.
+ List<DartType> result = new List<DartType>.generate(
+ typeVariables!.length,
+ (int i) => typeVariables![i]
+ .defaultType!
+ // TODO(johnniwinther): Using [libraryBuilder] here instead of
+ // [library] preserves the nullability of the original
+ // declaration. We legacy erase it later, but should we legacy
+ // erase it now also?
+ .buildAliased(libraryBuilder, TypeUse.defaultTypeAsTypeArgument),
growable: true);
if (library is SourceLibraryBuilder) {
library.inferredTypes.addAll(result);
@@ -218,19 +216,11 @@
}
// arguments.length == typeVariables.length
- return new List<DartType>.generate(
- arguments!.length, (int i) => arguments[i].build(library),
+ return new List<DartType>.generate(arguments!.length,
+ (int i) => arguments[i].buildAliased(library, TypeUse.typeArgument),
growable: true);
}
- void checkTypesInOutline(TypeEnvironment typeEnvironment) {
- libraryBuilder.checkBoundsInTypeParameters(
- typeEnvironment, typedef.typeParameters, fileUri);
- libraryBuilder.checkBoundsInType(
- typedef.type!, typeEnvironment, fileUri, type?.charOffset ?? charOffset,
- allowSuperBounded: false);
- }
-
void buildOutlineExpressions(
ClassHierarchy classHierarchy,
List<DelayedActionPerformer> delayedActionPerformers,
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_demotion.dart b/pkg/front_end/lib/src/fasta/type_inference/type_demotion.dart
index 9e4a88b..48a0929 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_demotion.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_demotion.dart
@@ -26,10 +26,6 @@
for (NamedType namedParameterType in node.namedParameters) {
if (namedParameterType.type.accept(this)) return true;
}
- TypedefType? typedefType = node.typedefType;
- if (typedefType != null && typedefType.accept(this)) {
- return true;
- }
return false;
}
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 609515e..979bf9d 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -10,7 +10,8 @@
import 'package:kernel/canonical_name.dart' as kernel;
import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
import 'package:kernel/core_types.dart' show CoreTypes;
-import 'package:kernel/src/bounds_checks.dart' show calculateBounds;
+import 'package:kernel/src/bounds_checks.dart'
+ show calculateBounds, isGenericFunctionTypeOrAlias;
import 'package:kernel/src/future_value_type.dart';
import 'package:kernel/src/legacy_erasure.dart';
import 'package:kernel/type_algebra.dart';
@@ -4875,6 +4876,22 @@
return new EqualsNull(left)..fileOffset = fileOffset;
}
+ /// Reports an error if [typeArgument] is a generic function type.
+ ///
+ /// This is use for reporting generic function types used as a type argument,
+ /// which was disallowed before the 'generic-metadata' feature was enabled.
+ void checkGenericFunctionTypeArgument(DartType typeArgument, int fileOffset) {
+ assert(!libraryBuilder.libraryFeatures.genericMetadata.isEnabled);
+ if (isGenericFunctionTypeOrAlias(typeArgument)) {
+ libraryBuilder.addProblem(
+ templateGenericFunctionTypeInferredAsActualTypeArgument.withArguments(
+ typeArgument, isNonNullableByDefault),
+ fileOffset,
+ noLength,
+ helper!.uri);
+ }
+ }
+
DartType _computeInferredType(ExpressionInferenceResult result) =>
identical(result.inferredType, noInferredType) || isNonNullableByDefault
? result.inferredType
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart b/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
index acd6439..54c2b25 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_schema.dart
@@ -13,6 +13,7 @@
NamedType,
Nullability,
TypedefType,
+ TypeParameter,
Visitor;
import 'package:kernel/src/assumptions.dart';
import 'package:kernel/src/printer.dart';
@@ -122,8 +123,9 @@
for (NamedType namedParameterType in node.namedParameters) {
if (!namedParameterType.type.accept(this)) return false;
}
- if (node.typedefType != null && !node.typedefType!.accept(this)) {
- return false;
+ for (TypeParameter typeParameter in node.typeParameters) {
+ if (!typeParameter.bound.accept(this)) return false;
+ if (!typeParameter.defaultType.accept(this)) return false;
}
return true;
}
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart b/pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart
index dd2f233..aeb7072 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart
@@ -49,10 +49,7 @@
isRequired: named.isRequired))
.toList(),
typeParameters: newTypeParameters,
- requiredParameterCount: type.requiredParameterCount,
- typedefType: type.typedefType == null
- ? null
- : substitution.substituteType(type.typedefType!) as TypedefType);
+ requiredParameterCount: type.requiredParameterCount);
}
/// Given a [FunctionType], gets the type of the named parameter with the given
diff --git a/pkg/front_end/lib/src/fasta/uris.dart b/pkg/front_end/lib/src/fasta/uris.dart
new file mode 100644
index 0000000..28dc2e2
--- /dev/null
+++ b/pkg/front_end/lib/src/fasta/uris.dart
@@ -0,0 +1,6 @@
+// Copyright (c) 2022, 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.
+
+final Uri dartCore = Uri.parse('dart:core');
+final Uri missingUri = Uri.parse('org-dartlang-internal:missing');
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index dae8e71..125a09d 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -429,6 +429,7 @@
FunctionTypedParameterVar/script1: Fail
FunctionUsedAsDec/analyzerCode: Fail
GeneratorReturnsValue/example: Fail
+GenericFunctionTypeAsTypeArgumentThroughTypedef/example: Fail
GetterNotFound/example: Fail
GetterWithFormals/example: Fail
IllegalAssignmentToNonAssignable/part_wrapped_script1: Fail
@@ -467,9 +468,6 @@
IncompatibleRedirecteeFunctionType/part_wrapped_script6: Fail
IncompatibleRedirecteeFunctionType/script6: Fail # Triggers multiple errors.
IncompatibleRedirecteeFunctionTypeWarning/example: Fail
-IncorrectTypeArgumentInReturnTypeWarning/example: Fail
-IncorrectTypeArgumentInSupertypeInferredWarning/example: Fail
-IncorrectTypeArgumentInSupertypeWarning/example: Fail
IncorrectTypeArgumentInferredWarning/example: Fail
IncorrectTypeArgumentQualifiedInferredWarning/example: Fail
IncorrectTypeArgumentQualifiedWarning/example: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index abf6263..745eead 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -4453,22 +4453,6 @@
class C<T> { foo<U extends num>() {} }
main() { new C<String>().foo<String>(); }
-IncorrectTypeArgumentInSupertype:
- problemMessage: "Type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the supertype '#name3' of class '#name4'."
- correctionMessage: "Try changing type arguments so that they conform to the bounds."
- analyzerCode: TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- script: >
- class A<T extends num> {}
- class B extends A<String> {}
-
-IncorrectTypeArgumentInReturnType:
- problemMessage: "Type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the return type."
- correctionMessage: "Try changing type arguments so that they conform to the bounds."
- analyzerCode: TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- script: >
- class A<T extends num> {}
- A<String> foo() => throw '';
-
IncorrectTypeArgumentInferred:
problemMessage: "Inferred type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2'."
correctionMessage: "Try specifying type arguments explicitly so that they conform to the bounds."
@@ -4485,14 +4469,6 @@
class C<T> { foo<U extends num>(U u) {} }
main() { new C<String>().foo(""); }
-IncorrectTypeArgumentInSupertypeInferred:
- problemMessage: "Inferred type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#name2' in the supertype '#name3' of class '#name4'."
- correctionMessage: "Try specifying type arguments explicitly so that they conform to the bounds."
- analyzerCode: TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- script: >
- class A<T extends A<T>> {}
- class B extends A {}
-
IncorrectTypeArgumentInstantiation:
problemMessage: "Type argument '#type' doesn't conform to the bound '#type2' of the type variable '#name' on '#type3'."
correctionMessage: "Try changing type arguments so that they conform to the bounds."
@@ -4560,6 +4536,11 @@
bar<Y>(Y y) => null;
main() { foo(bar); }
+GenericFunctionTypeAsTypeArgumentThroughTypedef:
+ problemMessage: "Generic function type '#type' used as a type argument through typedef '#type2'."
+ correctionMessage: "Try providing a non-generic function type explicitly."
+ analyzerCode: GENERIC_FUNCTION_CANNOT_BE_TYPE_ARGUMENT
+
# These two message templates are used for constructing supplemental text
# about the origins of raw interface types in error messages containing types.
TypeOrigin:
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index b143afe..6311cd6 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -60,6 +60,8 @@
arise
arising
arity
+arm
+arms
artifact
artifacts
artificial
@@ -259,6 +261,7 @@
contra
contribute
convention
+conversely
coordinated
coordinating
core
@@ -310,6 +313,7 @@
decl
decoupled
decreases
+dedupe
deduplication
deemed
deepest
@@ -343,6 +347,8 @@
destinations
destroy
destructive
+destructure
+destructuring
deterministic
dev
device
@@ -426,6 +432,7 @@
eq
equation
equivalences
+erase
erased
es
establish
@@ -437,9 +444,12 @@
executor
executors
exhausted
+exhaustively
+exhaustiveness
existence
existentially
exp
+expanded
expando
expense
experimentation
@@ -606,6 +616,7 @@
importantly
imprecise
improperly
+improves
inapplicable
inc
incomparable
@@ -618,6 +629,7 @@
indexing
indirection
individual
+individually
inequality
inequivalence
inequivalences
@@ -642,6 +654,7 @@
intends
intentionally
interested
+interfere
interim
interior
interleaved
@@ -650,6 +663,7 @@
interop
interpolations
interrupted
+intersections
intersects
interval
intervals
@@ -717,6 +731,7 @@
ld
leafp
leeway
+left's
len
lets
letting
@@ -765,6 +780,7 @@
macro
macros
maintaining
+malbounded
mangled
manipulation
manner
@@ -859,6 +875,7 @@
offending
ogham
oked
+omitting
op
opens
opt
@@ -879,6 +896,7 @@
outputs
outputting
overlap
+overlapping
overloader
overlooked
overshadowed
@@ -967,6 +985,7 @@
processor
producers
product
+profile
progresses
promo
proof
@@ -1115,6 +1134,7 @@
rf
rhs
ri
+right's
rightmost
risk
rn
@@ -1157,6 +1177,7 @@
serializables
serializer
serializers
+series
serve
server
serves
@@ -1263,6 +1284,7 @@
stringified
stringify
structs
+structurally
structures
stub
stubs
@@ -1275,15 +1297,22 @@
subexpression's
subexpressions
subgraph
+subname
subnode
subnodes
subscription
subsection
subsections
+subspace
+subspaces
subst
substed
substitutes
substitutor
+subtracted
+subtracting
+subtraction
+subtracts
suffixing
suggests
suite
@@ -1384,6 +1413,7 @@
tty
tuple
twos
+type's
typeref
u
ufeff
@@ -1421,6 +1451,7 @@
unifier
unifies
unify
+uninhabited
uninstantiable
uninstantiated
unintentionally
diff --git a/pkg/front_end/test/text_representation/data/types.dart b/pkg/front_end/test/text_representation/data/types.dart
index 029481c..4145fe9 100644
--- a/pkg/front_end/test/text_representation/data/types.dart
+++ b/pkg/front_end/test/text_representation/data/types.dart
@@ -155,51 +155,46 @@
// TODO(johnniwinther): Support interdependent function type variables.
//genericFunctionType5(T Function<T, S extends T>([T, S]) o) {}
//genericFunctionType6(T Function<T extends S, S>([T, S]) o) {}
-typedefType1(
- Typedef1 /*normal|limited.Typedef1*/ /*verbose.test::Typedef1*/ o) {}
+typedefType1(Typedef1 /*void Function()*/ o) {}
typedefType2(
Typedef2
- /*normal|limited.Typedef2<dynamic>*/
- /*verbose.test::Typedef2<dynamic>*/
+ /*void Function(dynamic)*/
o) {}
typedefType3(
Typedef2<int>
- /*normal|limited.Typedef2<int>*/
- /*verbose.test::Typedef2<dart.core::int>*/
+ /*normal|limited.void Function(int)*/
+ /*verbose.void Function(dart.core::int)*/
o1,
Typedef2<int?>
- /*normal|limited.Typedef2<int?>*/
- /*verbose.test::Typedef2<dart.core::int?>*/
+ /*normal|limited.void Function(int?)*/
+ /*verbose.void Function(dart.core::int?)*/
o2) {}
-typedefType4(
- Typedef3 /*normal|limited.Typedef3*/ /*verbose.test::Typedef3*/ o) {}
+typedefType4(Typedef3 /*void Function()*/ o) {}
typedefType5(
Typedef4
- /*normal|limited.Typedef4<dynamic>*/
-/*verbose.test::Typedef4<dynamic>*/
+ /*void Function(dynamic)*/
o) {}
typedefType7(
Typedef4<int>
- /*normal|limited.Typedef4<int>*/
- /*verbose.test::Typedef4<dart.core::int>*/
+ /*normal|limited.void Function(int)*/
+ /*verbose.void Function(dart.core::int)*/
o1,
Typedef4<int>?
- /*normal|limited.Typedef4<int>?*/
- /*verbose.test::Typedef4<dart.core::int>?*/
+ /*normal|limited.void Function(int)?*/
+ /*verbose.void Function(dart.core::int)?*/
o2) {}
typedefType8(
Typedef5
- /*normal|limited.Typedef5<dynamic>*/
- /*verbose.test::Typedef5<dynamic>*/
+ /*void Function<S>(dynamic, S%)*/
o) {}
typedefType9(
Typedef5<int>
- /*normal|limited.Typedef5<int>*/
- /*verbose.test::Typedef5<dart.core::int>*/
+ /*normal|limited.void Function<S>(int, S%)*/
+ /*verbose.void Function<S>(dart.core::int, S%)*/
o1,
Typedef5<int?>?
- /*normal|limited.Typedef5<int?>?*/
- /*verbose.test::Typedef5<dart.core::int?>?*/
+ /*normal|limited.void Function<S>(int?, S%)?*/
+ /*verbose.void Function<S>(dart.core::int?, S%)?*/
o2) {}
method() {
diff --git a/pkg/front_end/test/text_representation/data/types_opt_out.dart b/pkg/front_end/test/text_representation/data/types_opt_out.dart
index b864336..94c86e8 100644
--- a/pkg/front_end/test/text_representation/data/types_opt_out.dart
+++ b/pkg/front_end/test/text_representation/data/types_opt_out.dart
@@ -99,42 +99,37 @@
// TODO(johnniwinther): Support interdependent function type variables.
//genericFunctionType5(T Function<T, S extends T>([T, S]) o) {}
//genericFunctionType6(T Function<T extends S, S>([T, S]) o) {}
-typedefType1(
- Typedef1 /*normal|limited.Typedef1**/ /*verbose.test::Typedef1**/ o) {}
+typedefType1(Typedef1 /*void Function()**/ o) {}
typedefType2(
Typedef2
- /*normal|limited.Typedef2<dynamic>**/
- /*verbose.test::Typedef2<dynamic>**/
+ /*void Function(dynamic)**/
o) {}
typedefType3(
Typedef2<int>
- /*normal|limited.Typedef2<int*>**/
- /*verbose.test::Typedef2<dart.core::int*>**/
+ /*normal|limited.void Function(int*)**/
+ /*verbose.void Function(dart.core::int*)**/
o) {}
typedefType4(
Typedef3
- /*normal|limited.Typedef3**/
- /*verbose.test::Typedef3**/
+ /*void Function()**/
o) {}
typedefType5(
Typedef4
- /*normal|limited.Typedef4<dynamic>**/
- /*verbose.test::Typedef4<dynamic>**/
+ /*void Function(dynamic)**/
o) {}
typedefType7(
Typedef4<int>
- /*normal|limited.Typedef4<int*>**/
- /*verbose.test::Typedef4<dart.core::int*>**/
+ /*normal|limited.void Function(int*)**/
+ /*verbose.void Function(dart.core::int*)**/
o) {}
typedefType8(
Typedef5
- /*normal|limited.Typedef5<dynamic>**/
- /*verbose.test::Typedef5<dynamic>**/
+ /*void Function<S>(dynamic, S*)**/
o) {}
typedefType9(
Typedef5<int>
- /*normal|limited.Typedef5<int*>**/
- /*verbose.test::Typedef5<dart.core::int*>**/
+ /*normal|limited.void Function<S>(int*, S*)**/
+ /*verbose.void Function<S>(dart.core::int*, S*)**/
o) {}
method() {
diff --git a/pkg/front_end/test/text_representation/text_representation_test.dart b/pkg/front_end/test/text_representation/text_representation_test.dart
index 24e5246..b92bd42 100644
--- a/pkg/front_end/test/text_representation/text_representation_test.dart
+++ b/pkg/front_end/test/text_representation/text_representation_test.dart
@@ -181,11 +181,7 @@
return node.constant.toText(strategy);
} else if (node is VariableDeclaration) {
DartType type = node.type;
- if (type is FunctionType && type.typedefType != null) {
- return type.typedefType!.toText(strategy);
- } else {
- return type.toText(strategy);
- }
+ return type.toText(strategy);
}
return null;
}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart
new file mode 100644
index 0000000..05a8ef2
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart
@@ -0,0 +1,57 @@
+// Copyright (c) 2021, 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.
+
+import 'dart:async';
+
+// Introduce an aliased type.
+typedef T<X> = X;
+
+// Use the aliased type.
+
+T<int>? v1;
+List<T<void>> v2 = [];
+final T<String> v3 = throw "Anything";
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+abstract class C {
+ static T<C>? v1;
+ static List<T<T>> v2 = [];
+ static final T<Null> v3 = throw "Anything";
+ static const List<T<List>> v4 = [];
+
+ T<D>? v5;
+ List<T<T>> v6 = [];
+ final T<Null> v7;
+
+ C() : v7 = null;
+ C.name1(this.v5, this.v7);
+ factory C.name2(T<D> arg1, T<Null> arg2) = C1.name1;
+
+ T<double> operator +(T<double> other);
+ T<FutureOr<FutureOr<void>>> get g;
+ set g(T<FutureOr<FutureOr<void>>> value);
+ Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+ void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+class C1 implements C {
+ C1.name1(T<D> arg1, T<Null> arg2);
+ noSuchMethod(Invocation invocation) => throw 0;
+}
+
+class D {}
+
+extension E on T<dynamic> {
+ T<dynamic> foo(T<dynamic> t) => t;
+}
+
+main() {
+ var v8 = <T<C>>[];
+ var v9 = <Set<T<T>>, Set<T<T>>>{{}: {}};
+ var v10 = {v8};
+ v9[{}] = {42};
+ Set<List<T<C>>> v11 = v10;
+ v10 = v11;
+}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.expect
new file mode 100644
index 0000000..bc821c9
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.expect
@@ -0,0 +1,99 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1 = null;
+ static field core::List<dynamic> v2 = <dynamic>[];
+ static final field Null v3 = throw "Anything";
+ static const field core::List<core::List<dynamic>> v4 = #C1;
+ field self::D? v5;
+ field core::List<dynamic> v6 = <dynamic>[];
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
+ constructor •() → self::C
+ : self::C::v5 = null, self::C::v7 = null, super core::Object::•()
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ : self::C::v5 = v5, self::C::v7 = v7, super core::Object::•()
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ : super core::Object::•()
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ return throw 0;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ : super core::Object::•()
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2 = <void>[];
+static final field core::String v3 = throw "Anything";
+static const field core::List<self::C> v4 = #C5;
+static const field core::Map<core::Type, core::Type> v5 = #C7;
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ return t;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic {
+ core::List<self::C> v8 = <self::C>[];
+ core::Map<core::Set<dynamic>, core::Set<dynamic>> v9 = <core::Set<dynamic>, core::Set<dynamic>>{<dynamic>{}: <dynamic>{}};
+ core::Set<core::List<self::C>> v10 = <core::List<self::C>>{v8};
+ v9.{core::Map::[]=}(<dynamic>{}, <dynamic>{42}){(core::Set<dynamic>, core::Set<dynamic>) → void};
+ core::Set<core::List<self::C>> v11 = v10;
+ v10 = v11;
+}
+
+constants {
+ #C1 = <core::List<dynamic>>[]
+ #C2 = constructor-tearoff self::C::name2
+ #C3 = null
+ #C4 = <core::String, dynamic>{)
+ #C5 = <self::C>[]
+ #C6 = TypeLiteralConstant(dynamic)
+ #C7 = <core::Type, core::Type>{#C6:#C6)
+}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.transformed.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.transformed.expect
new file mode 100644
index 0000000..bc821c9
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.strong.transformed.expect
@@ -0,0 +1,99 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1 = null;
+ static field core::List<dynamic> v2 = <dynamic>[];
+ static final field Null v3 = throw "Anything";
+ static const field core::List<core::List<dynamic>> v4 = #C1;
+ field self::D? v5;
+ field core::List<dynamic> v6 = <dynamic>[];
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
+ constructor •() → self::C
+ : self::C::v5 = null, self::C::v7 = null, super core::Object::•()
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ : self::C::v5 = v5, self::C::v7 = v7, super core::Object::•()
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ : super core::Object::•()
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ return throw 0;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ : super core::Object::•()
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2 = <void>[];
+static final field core::String v3 = throw "Anything";
+static const field core::List<self::C> v4 = #C5;
+static const field core::Map<core::Type, core::Type> v5 = #C7;
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ return t;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic {
+ core::List<self::C> v8 = <self::C>[];
+ core::Map<core::Set<dynamic>, core::Set<dynamic>> v9 = <core::Set<dynamic>, core::Set<dynamic>>{<dynamic>{}: <dynamic>{}};
+ core::Set<core::List<self::C>> v10 = <core::List<self::C>>{v8};
+ v9.{core::Map::[]=}(<dynamic>{}, <dynamic>{42}){(core::Set<dynamic>, core::Set<dynamic>) → void};
+ core::Set<core::List<self::C>> v11 = v10;
+ v10 = v11;
+}
+
+constants {
+ #C1 = <core::List<dynamic>>[]
+ #C2 = constructor-tearoff self::C::name2
+ #C3 = null
+ #C4 = <core::String, dynamic>{)
+ #C5 = <self::C>[]
+ #C6 = TypeLiteralConstant(dynamic)
+ #C7 = <core::Type, core::Type>{#C6:#C6)
+}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline.expect
new file mode 100644
index 0000000..7421287
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline.expect
@@ -0,0 +1,39 @@
+import 'dart:async';
+
+typedef T<X> = X;
+T<int>? v1;
+List<T<void>> v2 = [];
+final T<String> v3 = throw "Anything";
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+abstract class C {
+ static T<C>? v1;
+ static List<T<T>> v2 = [];
+ static final T<Null> v3 = throw "Anything";
+ static const List<T<List>> v4 = [];
+ T<D>? v5;
+ List<T<T>> v6 = [];
+ final T<Null> v7;
+ C() : v7 = null;
+ C.name1(this.v5, this.v7);
+ factory C.name2(T<D> arg1, T<Null> arg2) = C1.name1;
+ T<double> operator +(T<double> other);
+ T<FutureOr<FutureOr<void>>> get g;
+ set g(T<FutureOr<FutureOr<void>>> value);
+ Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+ void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+class C1 implements C {
+ C1.name1(T<D> arg1, T<Null> arg2);
+ noSuchMethod(Invocation invocation) => throw 0;
+}
+
+class D {}
+
+extension E on T<dynamic> {
+ T<dynamic> foo(T<dynamic> t) => t;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..73acea0
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.textual_outline_modelled.expect
@@ -0,0 +1,40 @@
+import 'dart:async';
+
+List<T<void>> v2 = [];
+T<int>? v1;
+
+abstract class C {
+ C() : v7 = null;
+ C.name1(this.v5, this.v7);
+ List<T<T>> v6 = [];
+ Map<T<C>, T<C>> m1(covariant T<C> arg1, [Set<Set<T<C>>> arg2]);
+ T<D>? v5;
+ T<FutureOr<FutureOr<void>>> get g;
+ T<double> operator +(T<double> other);
+ factory C.name2(T<D> arg1, T<Null> arg2) = C1.name1;
+ final T<Null> v7;
+ set g(T<FutureOr<FutureOr<void>>> value);
+ static List<T<T>> v2 = [];
+ static T<C>? v1;
+ static const List<T<List>> v4 = [];
+ static final T<Null> v3 = throw "Anything";
+ void m2({T arg1, Map<T, T> arg2(T Function(T) arg21, T arg22)});
+}
+
+class C1 implements C {
+ C1.name1(T<D> arg1, T<Null> arg2);
+ noSuchMethod(Invocation invocation) => throw 0;
+}
+
+class D {}
+
+const List<T<C>> v4 = [];
+const v5 = <Type, Type>{T: T};
+
+extension E on T<dynamic> {
+ T<dynamic> foo(T<dynamic> t) => t;
+}
+
+final T<String> v3 = throw "Anything";
+main() {}
+typedef T<X> = X;
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.expect
new file mode 100644
index 0000000..5e2354d
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.expect
@@ -0,0 +1,99 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1 = null;
+ static field core::List<dynamic> v2 = <dynamic>[];
+ static final field Null v3 = throw "Anything";
+ static const field core::List<core::List<dynamic>> v4 = #C1;
+ field self::D? v5;
+ field core::List<dynamic> v6 = <dynamic>[];
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
+ constructor •() → self::C
+ : self::C::v5 = null, self::C::v7 = null, super core::Object::•()
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ : self::C::v5 = v5, self::C::v7 = v7, super core::Object::•()
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ : super core::Object::•()
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ return throw 0;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ : super core::Object::•()
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2 = <void>[];
+static final field core::String v3 = throw "Anything";
+static const field core::List<self::C> v4 = #C5;
+static const field core::Map<core::Type, core::Type> v5 = #C7;
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ return t;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic {
+ core::List<self::C> v8 = <self::C>[];
+ core::Map<core::Set<dynamic>, core::Set<dynamic>> v9 = <core::Set<dynamic>, core::Set<dynamic>>{<dynamic>{}: <dynamic>{}};
+ core::Set<core::List<self::C>> v10 = <core::List<self::C>>{v8};
+ v9.{core::Map::[]=}(<dynamic>{}, <dynamic>{42}){(core::Set<dynamic>, core::Set<dynamic>) → void};
+ core::Set<core::List<self::C>> v11 = v10;
+ v10 = v11;
+}
+
+constants {
+ #C1 = <core::List<dynamic>*>[]
+ #C2 = constructor-tearoff self::C::name2
+ #C3 = null
+ #C4 = <core::String*, dynamic>{)
+ #C5 = <self::C*>[]
+ #C6 = TypeLiteralConstant(dynamic)
+ #C7 = <core::Type*, core::Type*>{#C6:#C6)
+}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.modular.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.modular.expect
new file mode 100644
index 0000000..5e2354d
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.modular.expect
@@ -0,0 +1,99 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1 = null;
+ static field core::List<dynamic> v2 = <dynamic>[];
+ static final field Null v3 = throw "Anything";
+ static const field core::List<core::List<dynamic>> v4 = #C1;
+ field self::D? v5;
+ field core::List<dynamic> v6 = <dynamic>[];
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
+ constructor •() → self::C
+ : self::C::v5 = null, self::C::v7 = null, super core::Object::•()
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ : self::C::v5 = v5, self::C::v7 = v7, super core::Object::•()
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ : super core::Object::•()
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ return throw 0;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ : super core::Object::•()
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2 = <void>[];
+static final field core::String v3 = throw "Anything";
+static const field core::List<self::C> v4 = #C5;
+static const field core::Map<core::Type, core::Type> v5 = #C7;
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ return t;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic {
+ core::List<self::C> v8 = <self::C>[];
+ core::Map<core::Set<dynamic>, core::Set<dynamic>> v9 = <core::Set<dynamic>, core::Set<dynamic>>{<dynamic>{}: <dynamic>{}};
+ core::Set<core::List<self::C>> v10 = <core::List<self::C>>{v8};
+ v9.{core::Map::[]=}(<dynamic>{}, <dynamic>{42}){(core::Set<dynamic>, core::Set<dynamic>) → void};
+ core::Set<core::List<self::C>> v11 = v10;
+ v10 = v11;
+}
+
+constants {
+ #C1 = <core::List<dynamic>*>[]
+ #C2 = constructor-tearoff self::C::name2
+ #C3 = null
+ #C4 = <core::String*, dynamic>{)
+ #C5 = <self::C*>[]
+ #C6 = TypeLiteralConstant(dynamic)
+ #C7 = <core::Type*, core::Type*>{#C6:#C6)
+}
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.outline.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.outline.expect
new file mode 100644
index 0000000..5ba3b99
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.outline.expect
@@ -0,0 +1,96 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1;
+ static field core::List<dynamic> v2;
+ static final field Null v3;
+ static const field core::List<core::List<dynamic>> v4 = const <core::List<dynamic>>[];
+ field self::D? v5;
+ field core::List<dynamic> v6;
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[self::C::name2]/*isLegacy*/;
+ constructor •() → self::C
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = null]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = null, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = null}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ ;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], const <core::String, dynamic>{}, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], const <core::String, dynamic>{}, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], const <core::String, dynamic>{}, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], const <core::String, dynamic>{}, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], const <core::String, dynamic>{}, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], const <core::String, dynamic>{}, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], const <core::String, dynamic>{}, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], const <core::String, dynamic>{}, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], const <core::String, dynamic>{}, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2;
+static final field core::String v3;
+static const field core::List<self::C> v4 = const <self::C>[];
+static const field core::Map<core::Type, core::Type> v5 = const <core::Type, core::Type>{dynamic: dynamic};
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ ;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic
+ ;
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:22:35 -> ListConstant(const <List<dynamic>*>[])
+Evaluated: ConstructorTearOff @ org-dartlang-testcase:///generic_usage_type_variable.dart:18:16 -> ConstructorTearOffConstant(C.name2)
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:26:17 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:32:22 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:25:14 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:24:9 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:35:19 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:33:35 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:25:14 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:24:9 -> MapConstant(const <String*, dynamic>{})
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:34:7 -> MapConstant(const <String*, dynamic>{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:15:23 -> ListConstant(const <C*>[])
+Evaluated: MapLiteral @ org-dartlang-testcase:///generic_usage_type_variable.dart:16:24 -> MapConstant(const <Type*, Type*>{dynamic: dynamic})
+Extra constant evaluation: evaluated: 93, effectively constant: 13
diff --git a/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.transformed.expect b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.transformed.expect
new file mode 100644
index 0000000..5e2354d
--- /dev/null
+++ b/pkg/front_end/testcases/dart2js/generic_usage_type_variable.dart.weak.transformed.expect
@@ -0,0 +1,99 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "dart:async";
+
+typedef T<X extends core::Object? = dynamic> = X%;
+abstract class C extends core::Object {
+ static field self::C? v1 = null;
+ static field core::List<dynamic> v2 = <dynamic>[];
+ static final field Null v3 = throw "Anything";
+ static const field core::List<core::List<dynamic>> v4 = #C1;
+ field self::D? v5;
+ field core::List<dynamic> v6 = <dynamic>[];
+ final field Null v7;
+ static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
+ constructor •() → self::C
+ : self::C::v5 = null, self::C::v7 = null, super core::Object::•()
+ ;
+ constructor name1(self::D? v5, Null v7) → self::C
+ : self::C::v5 = v5, self::C::v7 = v7, super core::Object::•()
+ ;
+ static factory name2(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ static method _#name2#tearOff(self::D arg1, Null arg2) → self::C
+ return new self::C1::name1(arg1, arg2);
+ abstract operator +(core::double other) → core::double;
+ abstract get g() → FutureOr<FutureOr<void>>?;
+ abstract set g(FutureOr<FutureOr<void>>? value) → void;
+ abstract method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>;
+ abstract method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void;
+}
+class C1 extends core::Object implements self::C {
+ constructor name1(self::D arg1, Null arg2) → self::C1
+ : super core::Object::•()
+ ;
+ static method _#name1#tearOff(self::D arg1, Null arg2) → self::C1
+ return new self::C1::name1(arg1, arg2);
+ method noSuchMethod(core::Invocation invocation) → dynamic
+ return throw 0;
+ no-such-method-forwarder get v7() → Null
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v7", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} Null;
+ no-such-method-forwarder operator +(core::double other) → core::double
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("+", <dynamic>[], <dynamic>[other], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::double;
+ no-such-method-forwarder get v6() → core::List<dynamic>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::List<dynamic>;
+ no-such-method-forwarder get v5() → self::D?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} self::D?;
+ no-such-method-forwarder method m1(covariant-by-declaration self::C arg1, [core::Set<core::Set<self::C>> arg2 = #C3]) → core::Map<self::C, self::C>
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m1", <dynamic>[], <dynamic>[arg1, arg2], #C4, 0)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<self::C, self::C>;
+ no-such-method-forwarder method m2({dynamic arg1 = #C3, ((dynamic) → dynamic, dynamic) → core::Map<dynamic, dynamic> arg2 = #C3}) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("m2", <dynamic>[], <dynamic>[], <core::String, dynamic>{"arg1": arg1, "arg2": arg2}, 0)){(core::Invocation) → dynamic};
+ no-such-method-forwarder get g() → FutureOr<FutureOr<void>>?
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g", <dynamic>[], <dynamic>[], #C4, 1)){(core::Invocation) → dynamic} as{TypeError,ForDynamic,ForNonNullableByDefault} FutureOr<FutureOr<void>>?;
+ no-such-method-forwarder set v6(core::List<dynamic> value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v6=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set v5(self::D? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("v5=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+ no-such-method-forwarder set g(FutureOr<FutureOr<void>>? value) → void
+ return this.{self::C1::noSuchMethod}(core::_createInvocationMirror("g=", <dynamic>[], <dynamic>[value], #C4, 2)){(core::Invocation) → dynamic};
+}
+class D extends core::Object {
+ synthetic constructor •() → self::D
+ : super core::Object::•()
+ ;
+ static method _#new#tearOff() → self::D
+ return new self::D::•();
+}
+extension E on dynamic {
+ method foo = self::E|foo;
+ tearoff foo = self::E|get#foo;
+}
+static field core::int? v1;
+static field core::List<void> v2 = <void>[];
+static final field core::String v3 = throw "Anything";
+static const field core::List<self::C> v4 = #C5;
+static const field core::Map<core::Type, core::Type> v5 = #C7;
+static method E|foo(lowered final dynamic #this, dynamic t) → dynamic
+ return t;
+static method E|get#foo(lowered final dynamic #this) → (dynamic) → dynamic
+ return (dynamic t) → dynamic => self::E|foo(#this, t);
+static method main() → dynamic {
+ core::List<self::C> v8 = <self::C>[];
+ core::Map<core::Set<dynamic>, core::Set<dynamic>> v9 = <core::Set<dynamic>, core::Set<dynamic>>{<dynamic>{}: <dynamic>{}};
+ core::Set<core::List<self::C>> v10 = <core::List<self::C>>{v8};
+ v9.{core::Map::[]=}(<dynamic>{}, <dynamic>{42}){(core::Set<dynamic>, core::Set<dynamic>) → void};
+ core::Set<core::List<self::C>> v11 = v10;
+ v10 = v11;
+}
+
+constants {
+ #C1 = <core::List<dynamic>*>[]
+ #C2 = constructor-tearoff self::C::name2
+ #C3 = null
+ #C4 = <core::String*, dynamic>{)
+ #C5 = <self::C*>[]
+ #C6 = TypeLiteralConstant(dynamic)
+ #C7 = <core::Type*, core::Type*>{#C6:#C6)
+}
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart b/pkg/front_end/testcases/general/bounds_as_is.dart
new file mode 100644
index 0000000..419c5ae
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart
@@ -0,0 +1,47 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+t1a(o) => o as F; // Ok
+t2a(o) => o as F<dynamic>; // Ok
+t3a(o) => o as F<Class>; // Ok
+t4a(o) => o as F<Class<dynamic>>; // Ok
+t5a(o) => o as F<ConcreteClass>; // Ok
+t6a(o) => o as F<Class<ConcreteClass>>; // Ok
+t7a(o) => o as F<Object>; // Error
+t8a(o) => o as F<int>; // Error
+s1a(o) => o as G; // Ok
+s2a(o) => o as G<dynamic>; // Ok
+s3a(o) => o as G<Class>; // Ok
+s4a(o) => o as G<Class<dynamic>>; // Ok
+s5a(o) => o as G<ConcreteClass>; // Ok
+s6a(o) => o as G<Class<ConcreteClass>>; // Ok
+s7a(o) => o as G<Object>; // Error
+s8a(o) => o as G<int>; // Error
+
+t1b(o) => o is F; // Ok
+t2b(o) => o is F<dynamic>; // Ok
+t3b(o) => o is F<Class>; // Ok
+t4b(o) => o is F<Class<dynamic>>; // Ok
+t5b(o) => o is F<ConcreteClass>; // Ok
+t6b(o) => o is F<Class<ConcreteClass>>; // Ok
+t7b(o) => o is F<Object>; // Error
+t8b(o) => o is F<int>; // Error
+s1b(o) => o is G; // Ok
+s2b(o) => o is G<dynamic>; // Ok
+s3b(o) => o is G<Class>; // Ok
+s4b(o) => o is G<Class<dynamic>>; // Ok
+s5b(o) => o is G<ConcreteClass>; // Ok
+s6b(o) => o is G<Class<ConcreteClass>>; // Ok
+s7b(o) => o is G<Object>; // Error
+s8b(o) => o is G<int>; // Error
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline.expect
new file mode 100644
index 0000000..7555a22
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline.expect
@@ -0,0 +1,41 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+t1a(o) => o as F;
+t2a(o) => o as F<dynamic>;
+t3a(o) => o as F<Class>;
+t4a(o) => o as F<Class<dynamic>>;
+t5a(o) => o as F<ConcreteClass>;
+t6a(o) => o as F<Class<ConcreteClass>>;
+t7a(o) => o as F<Object>;
+t8a(o) => o as F<int>;
+s1a(o) => o as G;
+s2a(o) => o as G<dynamic>;
+s3a(o) => o as G<Class>;
+s4a(o) => o as G<Class<dynamic>>;
+s5a(o) => o as G<ConcreteClass>;
+s6a(o) => o as G<Class<ConcreteClass>>;
+s7a(o) => o as G<Object>;
+s8a(o) => o as G<int>;
+t1b(o) => o is F;
+t2b(o) => o is F<dynamic>;
+t3b(o) => o is F<Class>;
+t4b(o) => o is F<Class<dynamic>>;
+t5b(o) => o is F<ConcreteClass>;
+t6b(o) => o is F<Class<ConcreteClass>>;
+t7b(o) => o is F<Object>;
+t8b(o) => o is F<int>;
+s1b(o) => o is G;
+s2b(o) => o is G<dynamic>;
+s3b(o) => o is G<Class>;
+s4b(o) => o is G<Class<dynamic>>;
+s5b(o) => o is G<ConcreteClass>;
+s6b(o) => o is G<Class<ConcreteClass>>;
+s7b(o) => o is G<Object>;
+s8b(o) => o is G<int>;
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..733c503
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.textual_outline_modelled.expect
@@ -0,0 +1,40 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+s1a(o) => o as G;
+s1b(o) => o is G;
+s2a(o) => o as G<dynamic>;
+s2b(o) => o is G<dynamic>;
+s3a(o) => o as G<Class>;
+s3b(o) => o is G<Class>;
+s4a(o) => o as G<Class<dynamic>>;
+s4b(o) => o is G<Class<dynamic>>;
+s5a(o) => o as G<ConcreteClass>;
+s5b(o) => o is G<ConcreteClass>;
+s6a(o) => o as G<Class<ConcreteClass>>;
+s6b(o) => o is G<Class<ConcreteClass>>;
+s7a(o) => o as G<Object>;
+s7b(o) => o is G<Object>;
+s8a(o) => o as G<int>;
+s8b(o) => o is G<int>;
+t1a(o) => o as F;
+t1b(o) => o is F;
+t2a(o) => o as F<dynamic>;
+t2b(o) => o is F<dynamic>;
+t3a(o) => o as F<Class>;
+t3b(o) => o is F<Class>;
+t4a(o) => o as F<Class<dynamic>>;
+t4b(o) => o is F<Class<dynamic>>;
+t5a(o) => o as F<ConcreteClass>;
+t5b(o) => o is F<ConcreteClass>;
+t6a(o) => o as F<Class<ConcreteClass>>;
+t6b(o) => o is F<Class<ConcreteClass>>;
+t7a(o) => o as F<Object>;
+t7b(o) => o is F<Object>;
+t8a(o) => o as F<int>;
+t8b(o) => o is F<int>;
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.weak.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.expect
new file mode 100644
index 0000000..2156140
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.expect
@@ -0,0 +1,164 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:19:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7a(o) => o as F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:20:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8a(o) => o as F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:27:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7a(o) => o as G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:28:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8a(o) => o as G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:36:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7b(o) => o is F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:37:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8b(o) => o is F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:44:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7b(o) => o is G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:45:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8b(o) => o is G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} dynamic;
+static method t3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::ConcreteClass;
+static method t6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} core::Object;
+static method t8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} core::int;
+static method s1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<dynamic>;
+static method s3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::Object>;
+static method s8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::int>;
+static method t1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} dynamic;
+static method t3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::ConcreteClass;
+static method t6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::Object;
+static method t8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::int;
+static method s1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<dynamic>;
+static method s3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::Object>;
+static method s8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::int>;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.modular.expect
new file mode 100644
index 0000000..2156140
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.modular.expect
@@ -0,0 +1,164 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:19:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7a(o) => o as F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:20:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8a(o) => o as F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:27:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7a(o) => o as G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:28:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8a(o) => o as G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:36:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7b(o) => o is F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:37:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8b(o) => o is F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:44:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7b(o) => o is G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:45:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8b(o) => o is G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} dynamic;
+static method t3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::ConcreteClass;
+static method t6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} core::Object;
+static method t8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} core::int;
+static method s1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<dynamic>;
+static method s3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::Object>;
+static method s8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::int>;
+static method t1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} dynamic;
+static method t3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::ConcreteClass;
+static method t6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::Object;
+static method t8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::int;
+static method s1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<dynamic>;
+static method s3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::Object>;
+static method s8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::int>;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.outline.expect
new file mode 100644
index 0000000..1dafbce
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.outline.expect
@@ -0,0 +1,83 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+static method t1a(dynamic o) → dynamic
+ ;
+static method t2a(dynamic o) → dynamic
+ ;
+static method t3a(dynamic o) → dynamic
+ ;
+static method t4a(dynamic o) → dynamic
+ ;
+static method t5a(dynamic o) → dynamic
+ ;
+static method t6a(dynamic o) → dynamic
+ ;
+static method t7a(dynamic o) → dynamic
+ ;
+static method t8a(dynamic o) → dynamic
+ ;
+static method s1a(dynamic o) → dynamic
+ ;
+static method s2a(dynamic o) → dynamic
+ ;
+static method s3a(dynamic o) → dynamic
+ ;
+static method s4a(dynamic o) → dynamic
+ ;
+static method s5a(dynamic o) → dynamic
+ ;
+static method s6a(dynamic o) → dynamic
+ ;
+static method s7a(dynamic o) → dynamic
+ ;
+static method s8a(dynamic o) → dynamic
+ ;
+static method t1b(dynamic o) → dynamic
+ ;
+static method t2b(dynamic o) → dynamic
+ ;
+static method t3b(dynamic o) → dynamic
+ ;
+static method t4b(dynamic o) → dynamic
+ ;
+static method t5b(dynamic o) → dynamic
+ ;
+static method t6b(dynamic o) → dynamic
+ ;
+static method t7b(dynamic o) → dynamic
+ ;
+static method t8b(dynamic o) → dynamic
+ ;
+static method s1b(dynamic o) → dynamic
+ ;
+static method s2b(dynamic o) → dynamic
+ ;
+static method s3b(dynamic o) → dynamic
+ ;
+static method s4b(dynamic o) → dynamic
+ ;
+static method s5b(dynamic o) → dynamic
+ ;
+static method s6b(dynamic o) → dynamic
+ ;
+static method s7b(dynamic o) → dynamic
+ ;
+static method s8b(dynamic o) → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_as_is.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.transformed.expect
new file mode 100644
index 0000000..e45870b
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_as_is.dart.weak.transformed.expect
@@ -0,0 +1,164 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:19:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7a(o) => o as F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:20:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8a(o) => o as F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:27:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7a(o) => o as G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:28:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8a(o) => o as G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:36:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t7b(o) => o is F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:37:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// t8b(o) => o is F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:44:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s7b(o) => o is G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_as_is.dart:45:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_as_is.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// s8b(o) => o is G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_as_is.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} dynamic;
+static method t3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::ConcreteClass;
+static method t6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7a(dynamic o) → dynamic
+ return o;
+static method t8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} core::int;
+static method s1a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<dynamic>;
+static method s3a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::Object>;
+static method s8a(dynamic o) → dynamic
+ return o as{ForNonNullableByDefault} self::G<core::int>;
+static method t1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} dynamic;
+static method t3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<dynamic>;
+static method t5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::ConcreteClass;
+static method t6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::Class<self::ConcreteClass>;
+static method t7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::Object;
+static method t8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} core::int;
+static method s1b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s2b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<dynamic>;
+static method s3b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s4b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<dynamic>>;
+static method s5b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::ConcreteClass>;
+static method s6b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<self::Class<self::ConcreteClass>>;
+static method s7b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::Object>;
+static method s8b(dynamic o) → dynamic
+ return o is{ForNonNullableByDefault} self::G<core::int>;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart b/pkg/front_end/testcases/general/bounds_catch.dart
new file mode 100644
index 0000000..84f78bd
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart
@@ -0,0 +1,205 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+t1a() {
+ try {} on F catch (e) {
+ // Ok
+ }
+}
+
+t2a() {
+ try {} on F<dynamic> catch (e) {
+ // Ok
+ }
+}
+
+t3a() {
+ try {} on F<Class> catch (e) {
+ // Ok
+ }
+}
+
+t4a() {
+ try {} on F<Class<dynamic>> catch (e) {
+ // Ok
+ }
+}
+
+t5a() {
+ try {} on F<ConcreteClass> catch (e) {
+ // Ok
+ }
+}
+
+t6a() {
+ try {} on F<Class<ConcreteClass>> catch (e) {
+ // Ok
+ }
+}
+
+t7a() {
+ try {} on F<Object> catch (e) {
+ // Error
+ }
+}
+
+t8a() {
+ try {} on F<int> catch (e) {
+ // Error
+ }
+}
+
+s1a() {
+ try {} on G catch (e) {
+ // Ok
+ }
+}
+
+s2a() {
+ try {} on G<dynamic> catch (e) {
+ // Ok
+ }
+}
+
+s3a() {
+ try {} on G<Class> catch (e) {
+ // Ok
+ }
+}
+
+s4a() {
+ try {} on G<Class<dynamic>> catch (e) {
+ // Ok
+ }
+}
+
+s5a() {
+ try {} on G<ConcreteClass> catch (e) {
+ // Ok
+ }
+}
+
+s6a() {
+ try {} on G<Class<ConcreteClass>> catch (e) {
+ // Ok
+ }
+}
+
+s7a() {
+ try {} on G<Object> catch (e) {
+ // Error
+ }
+}
+
+s8a() {
+ try {} on G<int> catch (e) {
+ // Error
+ }
+}
+
+t1b() {
+ try {} on F catch (e) {
+ // Ok
+ }
+}
+
+t2b() {
+ try {} on F<dynamic> catch (e) {
+ // Ok
+ }
+}
+
+t3b() {
+ try {} on F<Class> catch (e) {
+ // Ok
+ }
+}
+
+t4b() {
+ try {} on F<Class<dynamic>> catch (e) {
+ // Ok
+ }
+}
+
+t5b() {
+ try {} on F<ConcreteClass> catch (e) {
+ // Ok
+ }
+}
+
+t6b() {
+ try {} on F<Class<ConcreteClass>> catch (e) {
+ // Ok
+ }
+}
+
+t7b() {
+ try {} on F<Object> catch (e) {
+ // Error
+ }
+}
+
+t8b() {
+ try {} on F<int> catch (e) {
+ // Error
+ }
+}
+
+s1b() {
+ try {} on G catch (e) {
+ // Ok
+ }
+}
+
+s2b() {
+ try {} on G<dynamic> catch (e) {
+ // Ok
+ }
+}
+
+s3b() {
+ try {} on G<Class> catch (e) {
+ // Ok
+ }
+}
+
+s4b() {
+ try {} on G<Class<dynamic>> catch (e) {
+ // Ok
+ }
+}
+
+s5b() {
+ try {} on G<ConcreteClass> catch (e) {
+ // Ok
+ }
+}
+
+s6b() {
+ try {} on G<Class<ConcreteClass>> catch (e) {
+ // Ok
+ }
+}
+
+s7b() {
+ try {} on G<Object> catch (e) {
+ // Error
+ }
+}
+
+s8b() {
+ try {} on G<int> catch (e) {
+ // Error
+ }
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline.expect
new file mode 100644
index 0000000..986be5e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline.expect
@@ -0,0 +1,41 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+t1a() {}
+t2a() {}
+t3a() {}
+t4a() {}
+t5a() {}
+t6a() {}
+t7a() {}
+t8a() {}
+s1a() {}
+s2a() {}
+s3a() {}
+s4a() {}
+s5a() {}
+s6a() {}
+s7a() {}
+s8a() {}
+t1b() {}
+t2b() {}
+t3b() {}
+t4b() {}
+t5b() {}
+t6b() {}
+t7b() {}
+t8b() {}
+s1b() {}
+s2b() {}
+s3b() {}
+s4b() {}
+s5b() {}
+s6b() {}
+s7b() {}
+s8b() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..ff62b0a
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.textual_outline_modelled.expect
@@ -0,0 +1,40 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+s1a() {}
+s1b() {}
+s2a() {}
+s2b() {}
+s3a() {}
+s3b() {}
+s4a() {}
+s4b() {}
+s5a() {}
+s5b() {}
+s6a() {}
+s6b() {}
+s7a() {}
+s7b() {}
+s8a() {}
+s8b() {}
+t1a() {}
+t1b() {}
+t2a() {}
+t2b() {}
+t3a() {}
+t3b() {}
+t4a() {}
+t4b() {}
+t5a() {}
+t5b() {}
+t6a() {}
+t6b() {}
+t7a() {}
+t7b() {}
+t8a() {}
+t8b() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.weak.expect b/pkg/front_end/testcases/general/bounds_catch.dart.weak.expect
new file mode 100644
index 0000000..d56af17
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.weak.expect
@@ -0,0 +1,292 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:50:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:56:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:98:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:104:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:146:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:152:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:194:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:200:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2a() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5a() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6a() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7a() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8a() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2a() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5a() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7a() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8a() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method t1b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2b() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5b() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6b() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7b() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8b() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2b() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5b() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7b() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8b() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_catch.dart.weak.modular.expect
new file mode 100644
index 0000000..d56af17
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.weak.modular.expect
@@ -0,0 +1,292 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:50:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:56:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:98:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:104:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:146:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:152:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:194:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:200:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2a() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5a() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6a() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7a() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8a() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2a() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5a() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7a() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8a() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method t1b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2b() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5b() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6b() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7b() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8b() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2b() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5b() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7b() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8b() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_catch.dart.weak.outline.expect
new file mode 100644
index 0000000..1bd5e4a
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.weak.outline.expect
@@ -0,0 +1,83 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+static method t1a() → dynamic
+ ;
+static method t2a() → dynamic
+ ;
+static method t3a() → dynamic
+ ;
+static method t4a() → dynamic
+ ;
+static method t5a() → dynamic
+ ;
+static method t6a() → dynamic
+ ;
+static method t7a() → dynamic
+ ;
+static method t8a() → dynamic
+ ;
+static method s1a() → dynamic
+ ;
+static method s2a() → dynamic
+ ;
+static method s3a() → dynamic
+ ;
+static method s4a() → dynamic
+ ;
+static method s5a() → dynamic
+ ;
+static method s6a() → dynamic
+ ;
+static method s7a() → dynamic
+ ;
+static method s8a() → dynamic
+ ;
+static method t1b() → dynamic
+ ;
+static method t2b() → dynamic
+ ;
+static method t3b() → dynamic
+ ;
+static method t4b() → dynamic
+ ;
+static method t5b() → dynamic
+ ;
+static method t6b() → dynamic
+ ;
+static method t7b() → dynamic
+ ;
+static method t8b() → dynamic
+ ;
+static method s1b() → dynamic
+ ;
+static method s2b() → dynamic
+ ;
+static method s3b() → dynamic
+ ;
+static method s4b() → dynamic
+ ;
+static method s5b() → dynamic
+ ;
+static method s6b() → dynamic
+ ;
+static method s7b() → dynamic
+ ;
+static method s8b() → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_catch.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_catch.dart.weak.transformed.expect
new file mode 100644
index 0000000..d56af17
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_catch.dart.weak.transformed.expect
@@ -0,0 +1,292 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:50:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:56:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:98:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:104:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:146:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:152:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on F<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:194:13: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<Object> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_catch.dart:200:13: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_catch.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// try {} on G<int> catch (e) {
+// ^
+// pkg/front_end/testcases/general/bounds_catch.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method t1a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2a() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4a() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5a() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6a() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7a() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8a() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2a() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5a() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6a() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7a() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8a() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method t1b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t2b() → dynamic {
+ try {
+ }
+ on dynamic catch(final dynamic e) {
+ }
+}
+static method t3b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t4b() → dynamic {
+ try {
+ }
+ on self::Class<dynamic> catch(final self::Class<dynamic> e) {
+ }
+}
+static method t5b() → dynamic {
+ try {
+ }
+ on self::ConcreteClass catch(final self::ConcreteClass e) {
+ }
+}
+static method t6b() → dynamic {
+ try {
+ }
+ on self::Class<self::ConcreteClass> catch(final self::Class<self::ConcreteClass> e) {
+ }
+}
+static method t7b() → dynamic {
+ try {
+ }
+ on core::Object catch(final core::Object e) {
+ }
+}
+static method t8b() → dynamic {
+ try {
+ }
+ on core::int catch(final core::int e) {
+ }
+}
+static method s1b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s2b() → dynamic {
+ try {
+ }
+ on self::G<dynamic> catch(final self::G<dynamic> e) {
+ }
+}
+static method s3b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s4b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<dynamic>> catch(final self::G<self::Class<dynamic>> e) {
+ }
+}
+static method s5b() → dynamic {
+ try {
+ }
+ on self::G<self::ConcreteClass> catch(final self::G<self::ConcreteClass> e) {
+ }
+}
+static method s6b() → dynamic {
+ try {
+ }
+ on self::G<self::Class<self::ConcreteClass>> catch(final self::G<self::Class<self::ConcreteClass>> e) {
+ }
+}
+static method s7b() → dynamic {
+ try {
+ }
+ on self::G<core::Object> catch(final self::G<core::Object> e) {
+ }
+}
+static method s8b() → dynamic {
+ try {
+ }
+ on self::G<core::int> catch(final self::G<core::int> e) {
+ }
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.expect b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.expect
index 3cebc8b..3b587bb 100644
--- a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.expect
+++ b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:40: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:32: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef F = Function<Z extends A<Y>>() Function<Y extends num>();
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:18: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:61: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef G = void Function<Y extends num>(Function<Z extends A<Y>>());
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
diff --git a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.modular.expect
index 3cebc8b..3b587bb 100644
--- a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.modular.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:40: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:32: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef F = Function<Z extends A<Y>>() Function<Y extends num>();
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:18: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:61: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef G = void Function<Y extends num>(Function<Z extends A<Y>>());
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
diff --git a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.outline.expect
index d778825..9a4c7c1 100644
--- a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.outline.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:40: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:32: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef F = Function<Z extends A<Y>>() Function<Y extends num>();
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:18: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:61: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef G = void Function<Y extends num>(Function<Z extends A<Y>>());
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
diff --git a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.transformed.expect
index 3cebc8b..3b587bb 100644
--- a/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/bounds_check_in_typedef.dart.weak.transformed.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:40: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:7:32: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef F = Function<Z extends A<Y>>() Function<Y extends num>();
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
//
-// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:18: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:8:61: Error: Type argument 'Y' doesn't conform to the bound 'String' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// typedef G = void Function<Y extends num>(Function<Z extends A<Y>>());
-// ^
+// ^
// pkg/front_end/testcases/general/bounds_check_in_typedef.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends String> {}
// ^
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart b/pkg/front_end/testcases/general/bounds_enums.dart
new file mode 100644
index 0000000..d773c42
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart
@@ -0,0 +1,23 @@
+// Copyright (c) 2022, 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.
+
+// TODO(johnniwinther): Check/create this type as regular bounded i2b.
+
+typedef A<X> = X Function(X);
+
+class B<X> {}
+
+enum E1<Y extends A<Y>> /* Error */ {
+ e1<Never>() // Ok
+}
+
+enum E2<Y extends B<Y>> /* Error */ {
+ e2<Never>() // Ok
+}
+
+enum E3<Y extends E3<Y>> /* Error */ {
+ e3<Never>() // Ok
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline.expect
new file mode 100644
index 0000000..1fb4a64
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline.expect
@@ -0,0 +1,11 @@
+typedef A<X> = X Function(X);
+
+class B<X> {}
+
+enum E1<Y extends A<Y>> { e1<Never>() }
+
+enum E2<Y extends B<Y>> { e2<Never>() }
+
+enum E3<Y extends E3<Y>> { e3<Never>() }
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..2dba339
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.textual_outline_modelled.expect
@@ -0,0 +1,10 @@
+class B<X> {}
+
+enum E1<Y extends A<Y>> { e1<Never>() }
+
+enum E2<Y extends B<Y>> { e2<Never>() }
+
+enum E3<Y extends E3<Y>> { e3<Never>() }
+
+main() {}
+typedef A<X> = X Function(X);
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.weak.expect b/pkg/front_end/testcases/general/bounds_enums.dart.weak.expect
new file mode 100644
index 0000000..0ac15942
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.weak.expect
@@ -0,0 +1,75 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'Y Function(Y)' of the type variable 'Y' on 'E1'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Context: If you want 'E1<A<dynamic>>' to be a super-bounded type, note that the inverted type 'E1<A<Never>>' must then satisfy its bounds, which it does not.
+// - 'E1' is from 'pkg/front_end/testcases/general/bounds_enums.dart'.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef A<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class B<X extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::B<self::B::X%>
+ : super core::Object::•()
+ ;
+}
+class E1<Y extends (self::E1::Y) → self::E1::Y = (dynamic) → dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E1<(dynamic) → dynamic>> values = #C4;
+ static const field self::E1<Never> e1 = #C3;
+ const constructor •(core::int index, core::String name) → self::E1<self::E1::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E1.${this.{core::_Enum::_name}{core::String}}";
+}
+class E2<Y extends self::B<self::E2::Y> = self::B<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E2<self::B<dynamic>>> values = #C7;
+ static const field self::E2<Never> e2 = #C6;
+ const constructor •(core::int index, core::String name) → self::E2<self::E2::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E2.${this.{core::_Enum::_name}{core::String}}";
+}
+class E3<Y extends self::E3<self::E3::Y> = self::E3<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E3<self::E3<dynamic>>> values = #C10;
+ static const field self::E3<Never> e3 = #C9;
+ const constructor •(core::int index, core::String name) → self::E3<self::E3::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E3.${this.{core::_Enum::_name}{core::String}}";
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "e1"
+ #C3 = self::E1<Never*> {index:#C1, _name:#C2}
+ #C4 = <self::E1<dynamic>*>[#C3]
+ #C5 = "e2"
+ #C6 = self::E2<Never*> {index:#C1, _name:#C5}
+ #C7 = <self::E2<dynamic>*>[#C6]
+ #C8 = "e3"
+ #C9 = self::E3<Never*> {index:#C1, _name:#C8}
+ #C10 = <self::E3<dynamic>*>[#C9]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_enums.dart:
+- E1. (from org-dartlang-testcase:///bounds_enums.dart:11:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///bounds_enums.dart:15:6)
+- E3. (from org-dartlang-testcase:///bounds_enums.dart:19:6)
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_enums.dart.weak.modular.expect
new file mode 100644
index 0000000..0ac15942
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.weak.modular.expect
@@ -0,0 +1,75 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'Y Function(Y)' of the type variable 'Y' on 'E1'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Context: If you want 'E1<A<dynamic>>' to be a super-bounded type, note that the inverted type 'E1<A<Never>>' must then satisfy its bounds, which it does not.
+// - 'E1' is from 'pkg/front_end/testcases/general/bounds_enums.dart'.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef A<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class B<X extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::B<self::B::X%>
+ : super core::Object::•()
+ ;
+}
+class E1<Y extends (self::E1::Y) → self::E1::Y = (dynamic) → dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E1<(dynamic) → dynamic>> values = #C4;
+ static const field self::E1<Never> e1 = #C3;
+ const constructor •(core::int index, core::String name) → self::E1<self::E1::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E1.${this.{core::_Enum::_name}{core::String}}";
+}
+class E2<Y extends self::B<self::E2::Y> = self::B<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E2<self::B<dynamic>>> values = #C7;
+ static const field self::E2<Never> e2 = #C6;
+ const constructor •(core::int index, core::String name) → self::E2<self::E2::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E2.${this.{core::_Enum::_name}{core::String}}";
+}
+class E3<Y extends self::E3<self::E3::Y> = self::E3<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E3<self::E3<dynamic>>> values = #C10;
+ static const field self::E3<Never> e3 = #C9;
+ const constructor •(core::int index, core::String name) → self::E3<self::E3::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E3.${this.{core::_Enum::_name}{core::String}}";
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "e1"
+ #C3 = self::E1<Never*> {index:#C1, _name:#C2}
+ #C4 = <self::E1<dynamic>*>[#C3]
+ #C5 = "e2"
+ #C6 = self::E2<Never*> {index:#C1, _name:#C5}
+ #C7 = <self::E2<dynamic>*>[#C6]
+ #C8 = "e3"
+ #C9 = self::E3<Never*> {index:#C1, _name:#C8}
+ #C10 = <self::E3<dynamic>*>[#C9]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_enums.dart:
+- E1. (from org-dartlang-testcase:///bounds_enums.dart:11:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///bounds_enums.dart:15:6)
+- E3. (from org-dartlang-testcase:///bounds_enums.dart:19:6)
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_enums.dart.weak.outline.expect
new file mode 100644
index 0000000..8034688
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.weak.outline.expect
@@ -0,0 +1,63 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'Y Function(Y)' of the type variable 'Y' on 'E1'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Context: If you want 'E1<A<dynamic>>' to be a super-bounded type, note that the inverted type 'E1<A<Never>>' must then satisfy its bounds, which it does not.
+// - 'E1' is from 'pkg/front_end/testcases/general/bounds_enums.dart'.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef A<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class B<X extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::B<self::B::X%>
+ ;
+}
+class E1<Y extends (self::E1::Y) → self::E1::Y = (dynamic) → dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E1<(dynamic) → dynamic>> values = const <self::E1<dynamic>>[self::E1::e1];
+ static const field self::E1<Never> e1 = const self::E1::•<Never>(0, "e1");
+ const constructor •(core::int index, core::String name) → self::E1<self::E1::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E1.${this.{core::_Enum::_name}{core::String}}";
+}
+class E2<Y extends self::B<self::E2::Y> = self::B<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E2<self::B<dynamic>>> values = const <self::E2<dynamic>>[self::E2::e2];
+ static const field self::E2<Never> e2 = const self::E2::•<Never>(0, "e2");
+ const constructor •(core::int index, core::String name) → self::E2<self::E2::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E2.${this.{core::_Enum::_name}{core::String}}";
+}
+class E3<Y extends self::E3<self::E3::Y> = self::E3<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E3<self::E3<dynamic>>> values = const <self::E3<dynamic>>[self::E3::e3];
+ static const field self::E3<Never> e3 = const self::E3::•<Never>(0, "e3");
+ const constructor •(core::int index, core::String name) → self::E3<self::E3::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E3.${this.{core::_Enum::_name}{core::String}}";
+}
+static method main() → dynamic
+ ;
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_enums.dart:11:6 -> ListConstant(const <E1<dynamic>*>[const E1<Never*>{_Enum.index: 0, _Enum._name: "e1"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_enums.dart:12:3 -> InstanceConstant(const E1<Never*>{_Enum.index: 0, _Enum._name: "e1"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_enums.dart:15:6 -> ListConstant(const <E2<dynamic>*>[const E2<Never*>{_Enum.index: 0, _Enum._name: "e2"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_enums.dart:16:3 -> InstanceConstant(const E2<Never*>{_Enum.index: 0, _Enum._name: "e2"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_enums.dart:19:6 -> ListConstant(const <E3<dynamic>*>[const E3<Never*>{_Enum.index: 0, _Enum._name: "e3"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_enums.dart:20:3 -> InstanceConstant(const E3<Never*>{_Enum.index: 0, _Enum._name: "e3"})
+Extra constant evaluation: evaluated: 21, effectively constant: 6
diff --git a/pkg/front_end/testcases/general/bounds_enums.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_enums.dart.weak.transformed.expect
new file mode 100644
index 0000000..0ac15942
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_enums.dart.weak.transformed.expect
@@ -0,0 +1,75 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'Y Function(Y)' of the type variable 'Y' on 'E1'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+// pkg/front_end/testcases/general/bounds_enums.dart:11:6: Context: If you want 'E1<A<dynamic>>' to be a super-bounded type, note that the inverted type 'E1<A<Never>>' must then satisfy its bounds, which it does not.
+// - 'E1' is from 'pkg/front_end/testcases/general/bounds_enums.dart'.
+// enum E1<Y extends A<Y>> /* Error */ {
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef A<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class B<X extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::B<self::B::X%>
+ : super core::Object::•()
+ ;
+}
+class E1<Y extends (self::E1::Y) → self::E1::Y = (dynamic) → dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E1<(dynamic) → dynamic>> values = #C4;
+ static const field self::E1<Never> e1 = #C3;
+ const constructor •(core::int index, core::String name) → self::E1<self::E1::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E1.${this.{core::_Enum::_name}{core::String}}";
+}
+class E2<Y extends self::B<self::E2::Y> = self::B<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E2<self::B<dynamic>>> values = #C7;
+ static const field self::E2<Never> e2 = #C6;
+ const constructor •(core::int index, core::String name) → self::E2<self::E2::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E2.${this.{core::_Enum::_name}{core::String}}";
+}
+class E3<Y extends self::E3<self::E3::Y> = self::E3<dynamic>> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::E3<self::E3<dynamic>>> values = #C10;
+ static const field self::E3<Never> e3 = #C9;
+ const constructor •(core::int index, core::String name) → self::E3<self::E3::Y>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "E3.${this.{core::_Enum::_name}{core::String}}";
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "e1"
+ #C3 = self::E1<Never*> {index:#C1, _name:#C2}
+ #C4 = <self::E1<dynamic>*>[#C3]
+ #C5 = "e2"
+ #C6 = self::E2<Never*> {index:#C1, _name:#C5}
+ #C7 = <self::E2<dynamic>*>[#C6]
+ #C8 = "e3"
+ #C9 = self::E3<Never*> {index:#C1, _name:#C8}
+ #C10 = <self::E3<dynamic>*>[#C9]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_enums.dart:
+- E1. (from org-dartlang-testcase:///bounds_enums.dart:11:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///bounds_enums.dart:15:6)
+- E3. (from org-dartlang-testcase:///bounds_enums.dart:19:6)
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart b/pkg/front_end/testcases/general/bounds_fields.dart
new file mode 100644
index 0000000..b840fce
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart
@@ -0,0 +1,68 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+F? field1a, field1b; // Ok
+F<dynamic>? field2a, field2b; // Ok
+F<Class>? field3a, field3b; // Ok
+F<Class<dynamic>>? field4a, field4b; // Ok
+F<ConcreteClass>? field5a, field5b; // Ok
+F<Class<ConcreteClass>>? field6a, field6b; // Ok
+F<Object>? field7a, field7b; // Error
+F<int>? field8a, field8b; // Error
+G? field1c, field1d; // Ok
+G<dynamic>? field2c, field2d; // Ok
+G<Class>? field3c, field3d; // Ok
+G<Class<dynamic>>? field4c, field4d; // Ok
+G<ConcreteClass>? field5c, field5d; // Ok
+G<Class<ConcreteClass>>? field6c, field6d; // Ok
+G<Object>? field7c, field8d; // Error
+G<int>? field8c, field7d; // Error
+
+class Class1 {
+ F? field1a, field1b; // Ok
+ F<dynamic>? field2a, field2b; // Ok
+ F<Class>? field3a, field3b; // Ok
+ F<Class<dynamic>>? field4a, field4b; // Ok
+ F<ConcreteClass>? field5a, field5b; // Ok
+ F<Class<ConcreteClass>>? field6a, field6b; // Ok
+ F<Object>? field7a, field7b; // Error
+ F<int>? field8a, field8b; // Error
+ G? field1c, field1d; // Ok
+ G<dynamic>? field2c, field2d; // Ok
+ G<Class>? field3c, field3d; // Ok
+ G<Class<dynamic>>? field4c, field4d; // Ok
+ G<ConcreteClass>? field5c, field5d; // Ok
+ G<Class<ConcreteClass>>? field6c, field6d; // Ok
+ G<Object>? field7c, field8d; // Error
+ G<int>? field8c, field7d; // Error
+}
+
+extension Extension1 on int {
+ static F? field1a, field1b; // Ok
+ static F<dynamic>? field2a, field2b; // Ok
+ static F<Class>? field3a, field3b; // Ok
+ static F<Class<dynamic>>? field4a, field4b; // Ok
+ static F<ConcreteClass>? field5a, field5b; // Ok
+ static F<Class<ConcreteClass>>? field6a, field6b; // Ok
+ static F<Object>? field7a, field7b; // Error
+ static F<int>? field8a, field8b; // Error
+ static G? field1c, field1d; // Ok
+ static G<dynamic>? field2c, field2d; // Ok
+ static G<Class>? field3c, field3d; // Ok
+ static G<Class<dynamic>>? field4c, field4d; // Ok
+ static G<ConcreteClass>? field5c, field5d; // Ok
+ static G<Class<ConcreteClass>>? field6c, field6d; // Ok
+ static G<Object>? field7c, field8d; // Error
+ static G<int>? field8c, field7d; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline.expect
new file mode 100644
index 0000000..827a05b
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline.expect
@@ -0,0 +1,64 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+F? field1a, field1b;
+F<dynamic>? field2a, field2b;
+F<Class>? field3a, field3b;
+F<Class<dynamic>>? field4a, field4b;
+F<ConcreteClass>? field5a, field5b;
+F<Class<ConcreteClass>>? field6a, field6b;
+F<Object>? field7a, field7b;
+F<int>? field8a, field8b;
+G? field1c, field1d;
+G<dynamic>? field2c, field2d;
+G<Class>? field3c, field3d;
+G<Class<dynamic>>? field4c, field4d;
+G<ConcreteClass>? field5c, field5d;
+G<Class<ConcreteClass>>? field6c, field6d;
+G<Object>? field7c, field8d;
+G<int>? field8c, field7d;
+
+class Class1 {
+ F? field1a, field1b;
+ F<dynamic>? field2a, field2b;
+ F<Class>? field3a, field3b;
+ F<Class<dynamic>>? field4a, field4b;
+ F<ConcreteClass>? field5a, field5b;
+ F<Class<ConcreteClass>>? field6a, field6b;
+ F<Object>? field7a, field7b;
+ F<int>? field8a, field8b;
+ G? field1c, field1d;
+ G<dynamic>? field2c, field2d;
+ G<Class>? field3c, field3d;
+ G<Class<dynamic>>? field4c, field4d;
+ G<ConcreteClass>? field5c, field5d;
+ G<Class<ConcreteClass>>? field6c, field6d;
+ G<Object>? field7c, field8d;
+ G<int>? field8c, field7d;
+}
+
+extension Extension1 on int {
+ static F? field1a, field1b;
+ static F<dynamic>? field2a, field2b;
+ static F<Class>? field3a, field3b;
+ static F<Class<dynamic>>? field4a, field4b;
+ static F<ConcreteClass>? field5a, field5b;
+ static F<Class<ConcreteClass>>? field6a, field6b;
+ static F<Object>? field7a, field7b;
+ static F<int>? field8a, field8b;
+ static G? field1c, field1d;
+ static G<dynamic>? field2c, field2d;
+ static G<Class>? field3c, field3d;
+ static G<Class<dynamic>>? field4c, field4d;
+ static G<ConcreteClass>? field5c, field5d;
+ static G<Class<ConcreteClass>>? field6c, field6d;
+ static G<Object>? field7c, field8d;
+ static G<int>? field8c, field7d;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..064b48e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.textual_outline_modelled.expect
@@ -0,0 +1,63 @@
+F<Class<ConcreteClass>>? field6a, field6b;
+F<Class<dynamic>>? field4a, field4b;
+F<Class>? field3a, field3b;
+F<ConcreteClass>? field5a, field5b;
+F<Object>? field7a, field7b;
+F<dynamic>? field2a, field2b;
+F<int>? field8a, field8b;
+F? field1a, field1b;
+G<Class<ConcreteClass>>? field6c, field6d;
+G<Class<dynamic>>? field4c, field4d;
+G<Class>? field3c, field3d;
+G<ConcreteClass>? field5c, field5d;
+G<Object>? field7c, field8d;
+G<dynamic>? field2c, field2d;
+G<int>? field8c, field7d;
+G? field1c, field1d;
+
+class Class<T> {}
+
+class Class1 {
+ F<Class<ConcreteClass>>? field6a, field6b;
+ F<Class<dynamic>>? field4a, field4b;
+ F<Class>? field3a, field3b;
+ F<ConcreteClass>? field5a, field5b;
+ F<Object>? field7a, field7b;
+ F<dynamic>? field2a, field2b;
+ F<int>? field8a, field8b;
+ F? field1a, field1b;
+ G<Class<ConcreteClass>>? field6c, field6d;
+ G<Class<dynamic>>? field4c, field4d;
+ G<Class>? field3c, field3d;
+ G<ConcreteClass>? field5c, field5d;
+ G<Object>? field7c, field8d;
+ G<dynamic>? field2c, field2d;
+ G<int>? field8c, field7d;
+ G? field1c, field1d;
+}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+extension Extension1 on int {
+ static F<Class<ConcreteClass>>? field6a, field6b;
+ static F<Class<dynamic>>? field4a, field4b;
+ static F<Class>? field3a, field3b;
+ static F<ConcreteClass>? field5a, field5b;
+ static F<Object>? field7a, field7b;
+ static F<dynamic>? field2a, field2b;
+ static F<int>? field8a, field8b;
+ static F? field1a, field1b;
+ static G<Class<ConcreteClass>>? field6c, field6d;
+ static G<Class<dynamic>>? field4c, field4d;
+ static G<Class>? field3c, field3d;
+ static G<ConcreteClass>? field5c, field5d;
+ static G<Object>? field7c, field8d;
+ static G<dynamic>? field2c, field2d;
+ static G<int>? field8c, field7d;
+ static G? field1c, field1d;
+}
+
+main() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.weak.expect b/pkg/front_end/testcases/general/bounds_fields.dart.weak.expect
new file mode 100644
index 0000000..19cb0c7
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.weak.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:56:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:57:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:64:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:65:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ field self::Class<dynamic>? field1a = null;
+ field self::Class<dynamic>? field1b = null;
+ field dynamic field2a = null;
+ field dynamic field2b = null;
+ field self::Class<dynamic>? field3a = null;
+ field self::Class<dynamic>? field3b = null;
+ field self::Class<dynamic>? field4a = null;
+ field self::Class<dynamic>? field4b = null;
+ field self::ConcreteClass? field5a = null;
+ field self::ConcreteClass? field5b = null;
+ field self::Class<self::ConcreteClass>? field6a = null;
+ field self::Class<self::ConcreteClass>? field6b = null;
+ field core::Object? field7a = null;
+ field core::Object? field7b = null;
+ field core::int? field8a = null;
+ field core::int? field8b = null;
+ field self::G<self::Class<dynamic>>? field1c = null;
+ field self::G<self::Class<dynamic>>? field1d = null;
+ field self::G<dynamic>? field2c = null;
+ field self::G<dynamic>? field2d = null;
+ field self::G<self::Class<dynamic>>? field3c = null;
+ field self::G<self::Class<dynamic>>? field3d = null;
+ field self::G<self::Class<dynamic>>? field4c = null;
+ field self::G<self::Class<dynamic>>? field4d = null;
+ field self::G<self::ConcreteClass>? field5c = null;
+ field self::G<self::ConcreteClass>? field5d = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6c = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6d = null;
+ field self::G<core::Object>? field7c = null;
+ field self::G<core::Object>? field8d = null;
+ field self::G<core::int>? field8c = null;
+ field self::G<core::int>? field7d = null;
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+extension Extension1 on core::int {
+ static field field1a = self::Extension1|field1a;
+ static field field1b = self::Extension1|field1b;
+ static field field2a = self::Extension1|field2a;
+ static field field2b = self::Extension1|field2b;
+ static field field3a = self::Extension1|field3a;
+ static field field3b = self::Extension1|field3b;
+ static field field4a = self::Extension1|field4a;
+ static field field4b = self::Extension1|field4b;
+ static field field5a = self::Extension1|field5a;
+ static field field5b = self::Extension1|field5b;
+ static field field6a = self::Extension1|field6a;
+ static field field6b = self::Extension1|field6b;
+ static field field7a = self::Extension1|field7a;
+ static field field7b = self::Extension1|field7b;
+ static field field8a = self::Extension1|field8a;
+ static field field8b = self::Extension1|field8b;
+ static field field1c = self::Extension1|field1c;
+ static field field1d = self::Extension1|field1d;
+ static field field2c = self::Extension1|field2c;
+ static field field2d = self::Extension1|field2d;
+ static field field3c = self::Extension1|field3c;
+ static field field3d = self::Extension1|field3d;
+ static field field4c = self::Extension1|field4c;
+ static field field4d = self::Extension1|field4d;
+ static field field5c = self::Extension1|field5c;
+ static field field5d = self::Extension1|field5d;
+ static field field6c = self::Extension1|field6c;
+ static field field6d = self::Extension1|field6d;
+ static field field7c = self::Extension1|field7c;
+ static field field8d = self::Extension1|field8d;
+ static field field8c = self::Extension1|field8c;
+ static field field7d = self::Extension1|field7d;
+}
+static field self::Class<dynamic>? field1a;
+static field self::Class<dynamic>? field1b;
+static field dynamic field2a;
+static field dynamic field2b;
+static field self::Class<dynamic>? field3a;
+static field self::Class<dynamic>? field3b;
+static field self::Class<dynamic>? field4a;
+static field self::Class<dynamic>? field4b;
+static field self::ConcreteClass? field5a;
+static field self::ConcreteClass? field5b;
+static field self::Class<self::ConcreteClass>? field6a;
+static field self::Class<self::ConcreteClass>? field6b;
+static field core::Object? field7a;
+static field core::Object? field7b;
+static field core::int? field8a;
+static field core::int? field8b;
+static field self::G<self::Class<dynamic>>? field1c;
+static field self::G<self::Class<dynamic>>? field1d;
+static field self::G<dynamic>? field2c;
+static field self::G<dynamic>? field2d;
+static field self::G<self::Class<dynamic>>? field3c;
+static field self::G<self::Class<dynamic>>? field3d;
+static field self::G<self::Class<dynamic>>? field4c;
+static field self::G<self::Class<dynamic>>? field4d;
+static field self::G<self::ConcreteClass>? field5c;
+static field self::G<self::ConcreteClass>? field5d;
+static field self::G<self::Class<self::ConcreteClass>>? field6c;
+static field self::G<self::Class<self::ConcreteClass>>? field6d;
+static field self::G<core::Object>? field7c;
+static field self::G<core::Object>? field8d;
+static field self::G<core::int>? field8c;
+static field self::G<core::int>? field7d;
+static field self::Class<dynamic>? Extension1|field1a;
+static field self::Class<dynamic>? Extension1|field1b;
+static field dynamic Extension1|field2a;
+static field dynamic Extension1|field2b;
+static field self::Class<dynamic>? Extension1|field3a;
+static field self::Class<dynamic>? Extension1|field3b;
+static field self::Class<dynamic>? Extension1|field4a;
+static field self::Class<dynamic>? Extension1|field4b;
+static field self::ConcreteClass? Extension1|field5a;
+static field self::ConcreteClass? Extension1|field5b;
+static field self::Class<self::ConcreteClass>? Extension1|field6a;
+static field self::Class<self::ConcreteClass>? Extension1|field6b;
+static field core::Object? Extension1|field7a;
+static field core::Object? Extension1|field7b;
+static field core::int? Extension1|field8a;
+static field core::int? Extension1|field8b;
+static field self::G<self::Class<dynamic>>? Extension1|field1c;
+static field self::G<self::Class<dynamic>>? Extension1|field1d;
+static field self::G<dynamic>? Extension1|field2c;
+static field self::G<dynamic>? Extension1|field2d;
+static field self::G<self::Class<dynamic>>? Extension1|field3c;
+static field self::G<self::Class<dynamic>>? Extension1|field3d;
+static field self::G<self::Class<dynamic>>? Extension1|field4c;
+static field self::G<self::Class<dynamic>>? Extension1|field4d;
+static field self::G<self::ConcreteClass>? Extension1|field5c;
+static field self::G<self::ConcreteClass>? Extension1|field5d;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6c;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6d;
+static field self::G<core::Object>? Extension1|field7c;
+static field self::G<core::Object>? Extension1|field8d;
+static field self::G<core::int>? Extension1|field8c;
+static field self::G<core::int>? Extension1|field7d;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_fields.dart.weak.modular.expect
new file mode 100644
index 0000000..19cb0c7
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.weak.modular.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:56:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:57:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:64:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:65:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ field self::Class<dynamic>? field1a = null;
+ field self::Class<dynamic>? field1b = null;
+ field dynamic field2a = null;
+ field dynamic field2b = null;
+ field self::Class<dynamic>? field3a = null;
+ field self::Class<dynamic>? field3b = null;
+ field self::Class<dynamic>? field4a = null;
+ field self::Class<dynamic>? field4b = null;
+ field self::ConcreteClass? field5a = null;
+ field self::ConcreteClass? field5b = null;
+ field self::Class<self::ConcreteClass>? field6a = null;
+ field self::Class<self::ConcreteClass>? field6b = null;
+ field core::Object? field7a = null;
+ field core::Object? field7b = null;
+ field core::int? field8a = null;
+ field core::int? field8b = null;
+ field self::G<self::Class<dynamic>>? field1c = null;
+ field self::G<self::Class<dynamic>>? field1d = null;
+ field self::G<dynamic>? field2c = null;
+ field self::G<dynamic>? field2d = null;
+ field self::G<self::Class<dynamic>>? field3c = null;
+ field self::G<self::Class<dynamic>>? field3d = null;
+ field self::G<self::Class<dynamic>>? field4c = null;
+ field self::G<self::Class<dynamic>>? field4d = null;
+ field self::G<self::ConcreteClass>? field5c = null;
+ field self::G<self::ConcreteClass>? field5d = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6c = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6d = null;
+ field self::G<core::Object>? field7c = null;
+ field self::G<core::Object>? field8d = null;
+ field self::G<core::int>? field8c = null;
+ field self::G<core::int>? field7d = null;
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+extension Extension1 on core::int {
+ static field field1a = self::Extension1|field1a;
+ static field field1b = self::Extension1|field1b;
+ static field field2a = self::Extension1|field2a;
+ static field field2b = self::Extension1|field2b;
+ static field field3a = self::Extension1|field3a;
+ static field field3b = self::Extension1|field3b;
+ static field field4a = self::Extension1|field4a;
+ static field field4b = self::Extension1|field4b;
+ static field field5a = self::Extension1|field5a;
+ static field field5b = self::Extension1|field5b;
+ static field field6a = self::Extension1|field6a;
+ static field field6b = self::Extension1|field6b;
+ static field field7a = self::Extension1|field7a;
+ static field field7b = self::Extension1|field7b;
+ static field field8a = self::Extension1|field8a;
+ static field field8b = self::Extension1|field8b;
+ static field field1c = self::Extension1|field1c;
+ static field field1d = self::Extension1|field1d;
+ static field field2c = self::Extension1|field2c;
+ static field field2d = self::Extension1|field2d;
+ static field field3c = self::Extension1|field3c;
+ static field field3d = self::Extension1|field3d;
+ static field field4c = self::Extension1|field4c;
+ static field field4d = self::Extension1|field4d;
+ static field field5c = self::Extension1|field5c;
+ static field field5d = self::Extension1|field5d;
+ static field field6c = self::Extension1|field6c;
+ static field field6d = self::Extension1|field6d;
+ static field field7c = self::Extension1|field7c;
+ static field field8d = self::Extension1|field8d;
+ static field field8c = self::Extension1|field8c;
+ static field field7d = self::Extension1|field7d;
+}
+static field self::Class<dynamic>? field1a;
+static field self::Class<dynamic>? field1b;
+static field dynamic field2a;
+static field dynamic field2b;
+static field self::Class<dynamic>? field3a;
+static field self::Class<dynamic>? field3b;
+static field self::Class<dynamic>? field4a;
+static field self::Class<dynamic>? field4b;
+static field self::ConcreteClass? field5a;
+static field self::ConcreteClass? field5b;
+static field self::Class<self::ConcreteClass>? field6a;
+static field self::Class<self::ConcreteClass>? field6b;
+static field core::Object? field7a;
+static field core::Object? field7b;
+static field core::int? field8a;
+static field core::int? field8b;
+static field self::G<self::Class<dynamic>>? field1c;
+static field self::G<self::Class<dynamic>>? field1d;
+static field self::G<dynamic>? field2c;
+static field self::G<dynamic>? field2d;
+static field self::G<self::Class<dynamic>>? field3c;
+static field self::G<self::Class<dynamic>>? field3d;
+static field self::G<self::Class<dynamic>>? field4c;
+static field self::G<self::Class<dynamic>>? field4d;
+static field self::G<self::ConcreteClass>? field5c;
+static field self::G<self::ConcreteClass>? field5d;
+static field self::G<self::Class<self::ConcreteClass>>? field6c;
+static field self::G<self::Class<self::ConcreteClass>>? field6d;
+static field self::G<core::Object>? field7c;
+static field self::G<core::Object>? field8d;
+static field self::G<core::int>? field8c;
+static field self::G<core::int>? field7d;
+static field self::Class<dynamic>? Extension1|field1a;
+static field self::Class<dynamic>? Extension1|field1b;
+static field dynamic Extension1|field2a;
+static field dynamic Extension1|field2b;
+static field self::Class<dynamic>? Extension1|field3a;
+static field self::Class<dynamic>? Extension1|field3b;
+static field self::Class<dynamic>? Extension1|field4a;
+static field self::Class<dynamic>? Extension1|field4b;
+static field self::ConcreteClass? Extension1|field5a;
+static field self::ConcreteClass? Extension1|field5b;
+static field self::Class<self::ConcreteClass>? Extension1|field6a;
+static field self::Class<self::ConcreteClass>? Extension1|field6b;
+static field core::Object? Extension1|field7a;
+static field core::Object? Extension1|field7b;
+static field core::int? Extension1|field8a;
+static field core::int? Extension1|field8b;
+static field self::G<self::Class<dynamic>>? Extension1|field1c;
+static field self::G<self::Class<dynamic>>? Extension1|field1d;
+static field self::G<dynamic>? Extension1|field2c;
+static field self::G<dynamic>? Extension1|field2d;
+static field self::G<self::Class<dynamic>>? Extension1|field3c;
+static field self::G<self::Class<dynamic>>? Extension1|field3d;
+static field self::G<self::Class<dynamic>>? Extension1|field4c;
+static field self::G<self::Class<dynamic>>? Extension1|field4d;
+static field self::G<self::ConcreteClass>? Extension1|field5c;
+static field self::G<self::ConcreteClass>? Extension1|field5d;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6c;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6d;
+static field self::G<core::Object>? Extension1|field7c;
+static field self::G<core::Object>? Extension1|field8d;
+static field self::G<core::int>? Extension1|field8c;
+static field self::G<core::int>? Extension1|field7d;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_fields.dart.weak.outline.expect
new file mode 100644
index 0000000..58b2e77
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.weak.outline.expect
@@ -0,0 +1,270 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:56:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:57:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:64:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:65:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1 extends core::Object {
+ field self::Class<dynamic>? field1a;
+ field self::Class<dynamic>? field1b;
+ field dynamic field2a;
+ field dynamic field2b;
+ field self::Class<dynamic>? field3a;
+ field self::Class<dynamic>? field3b;
+ field self::Class<dynamic>? field4a;
+ field self::Class<dynamic>? field4b;
+ field self::ConcreteClass? field5a;
+ field self::ConcreteClass? field5b;
+ field self::Class<self::ConcreteClass>? field6a;
+ field self::Class<self::ConcreteClass>? field6b;
+ field core::Object? field7a;
+ field core::Object? field7b;
+ field core::int? field8a;
+ field core::int? field8b;
+ field self::G<self::Class<dynamic>>? field1c;
+ field self::G<self::Class<dynamic>>? field1d;
+ field self::G<dynamic>? field2c;
+ field self::G<dynamic>? field2d;
+ field self::G<self::Class<dynamic>>? field3c;
+ field self::G<self::Class<dynamic>>? field3d;
+ field self::G<self::Class<dynamic>>? field4c;
+ field self::G<self::Class<dynamic>>? field4d;
+ field self::G<self::ConcreteClass>? field5c;
+ field self::G<self::ConcreteClass>? field5d;
+ field self::G<self::Class<self::ConcreteClass>>? field6c;
+ field self::G<self::Class<self::ConcreteClass>>? field6d;
+ field self::G<core::Object>? field7c;
+ field self::G<core::Object>? field8d;
+ field self::G<core::int>? field8c;
+ field self::G<core::int>? field7d;
+ synthetic constructor •() → self::Class1
+ ;
+}
+extension Extension1 on core::int {
+ static field field1a = self::Extension1|field1a;
+ static field field1b = self::Extension1|field1b;
+ static field field2a = self::Extension1|field2a;
+ static field field2b = self::Extension1|field2b;
+ static field field3a = self::Extension1|field3a;
+ static field field3b = self::Extension1|field3b;
+ static field field4a = self::Extension1|field4a;
+ static field field4b = self::Extension1|field4b;
+ static field field5a = self::Extension1|field5a;
+ static field field5b = self::Extension1|field5b;
+ static field field6a = self::Extension1|field6a;
+ static field field6b = self::Extension1|field6b;
+ static field field7a = self::Extension1|field7a;
+ static field field7b = self::Extension1|field7b;
+ static field field8a = self::Extension1|field8a;
+ static field field8b = self::Extension1|field8b;
+ static field field1c = self::Extension1|field1c;
+ static field field1d = self::Extension1|field1d;
+ static field field2c = self::Extension1|field2c;
+ static field field2d = self::Extension1|field2d;
+ static field field3c = self::Extension1|field3c;
+ static field field3d = self::Extension1|field3d;
+ static field field4c = self::Extension1|field4c;
+ static field field4d = self::Extension1|field4d;
+ static field field5c = self::Extension1|field5c;
+ static field field5d = self::Extension1|field5d;
+ static field field6c = self::Extension1|field6c;
+ static field field6d = self::Extension1|field6d;
+ static field field7c = self::Extension1|field7c;
+ static field field8d = self::Extension1|field8d;
+ static field field8c = self::Extension1|field8c;
+ static field field7d = self::Extension1|field7d;
+}
+static field self::Class<dynamic>? field1a;
+static field self::Class<dynamic>? field1b;
+static field dynamic field2a;
+static field dynamic field2b;
+static field self::Class<dynamic>? field3a;
+static field self::Class<dynamic>? field3b;
+static field self::Class<dynamic>? field4a;
+static field self::Class<dynamic>? field4b;
+static field self::ConcreteClass? field5a;
+static field self::ConcreteClass? field5b;
+static field self::Class<self::ConcreteClass>? field6a;
+static field self::Class<self::ConcreteClass>? field6b;
+static field core::Object? field7a;
+static field core::Object? field7b;
+static field core::int? field8a;
+static field core::int? field8b;
+static field self::G<self::Class<dynamic>>? field1c;
+static field self::G<self::Class<dynamic>>? field1d;
+static field self::G<dynamic>? field2c;
+static field self::G<dynamic>? field2d;
+static field self::G<self::Class<dynamic>>? field3c;
+static field self::G<self::Class<dynamic>>? field3d;
+static field self::G<self::Class<dynamic>>? field4c;
+static field self::G<self::Class<dynamic>>? field4d;
+static field self::G<self::ConcreteClass>? field5c;
+static field self::G<self::ConcreteClass>? field5d;
+static field self::G<self::Class<self::ConcreteClass>>? field6c;
+static field self::G<self::Class<self::ConcreteClass>>? field6d;
+static field self::G<core::Object>? field7c;
+static field self::G<core::Object>? field8d;
+static field self::G<core::int>? field8c;
+static field self::G<core::int>? field7d;
+static field self::Class<dynamic>? Extension1|field1a;
+static field self::Class<dynamic>? Extension1|field1b;
+static field dynamic Extension1|field2a;
+static field dynamic Extension1|field2b;
+static field self::Class<dynamic>? Extension1|field3a;
+static field self::Class<dynamic>? Extension1|field3b;
+static field self::Class<dynamic>? Extension1|field4a;
+static field self::Class<dynamic>? Extension1|field4b;
+static field self::ConcreteClass? Extension1|field5a;
+static field self::ConcreteClass? Extension1|field5b;
+static field self::Class<self::ConcreteClass>? Extension1|field6a;
+static field self::Class<self::ConcreteClass>? Extension1|field6b;
+static field core::Object? Extension1|field7a;
+static field core::Object? Extension1|field7b;
+static field core::int? Extension1|field8a;
+static field core::int? Extension1|field8b;
+static field self::G<self::Class<dynamic>>? Extension1|field1c;
+static field self::G<self::Class<dynamic>>? Extension1|field1d;
+static field self::G<dynamic>? Extension1|field2c;
+static field self::G<dynamic>? Extension1|field2d;
+static field self::G<self::Class<dynamic>>? Extension1|field3c;
+static field self::G<self::Class<dynamic>>? Extension1|field3d;
+static field self::G<self::Class<dynamic>>? Extension1|field4c;
+static field self::G<self::Class<dynamic>>? Extension1|field4d;
+static field self::G<self::ConcreteClass>? Extension1|field5c;
+static field self::G<self::ConcreteClass>? Extension1|field5d;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6c;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6d;
+static field self::G<core::Object>? Extension1|field7c;
+static field self::G<core::Object>? Extension1|field8d;
+static field self::G<core::int>? Extension1|field8c;
+static field self::G<core::int>? Extension1|field7d;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_fields.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_fields.dart.weak.transformed.expect
new file mode 100644
index 0000000..19cb0c7
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_fields.dart.weak.transformed.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:56:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<Object>? field7a, field7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:57:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static F<int>? field8a, field8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:64:10: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<Object>? field7c, field8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_fields.dart:65:10: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_fields.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// static G<int>? field8c, field7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_fields.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ field self::Class<dynamic>? field1a = null;
+ field self::Class<dynamic>? field1b = null;
+ field dynamic field2a = null;
+ field dynamic field2b = null;
+ field self::Class<dynamic>? field3a = null;
+ field self::Class<dynamic>? field3b = null;
+ field self::Class<dynamic>? field4a = null;
+ field self::Class<dynamic>? field4b = null;
+ field self::ConcreteClass? field5a = null;
+ field self::ConcreteClass? field5b = null;
+ field self::Class<self::ConcreteClass>? field6a = null;
+ field self::Class<self::ConcreteClass>? field6b = null;
+ field core::Object? field7a = null;
+ field core::Object? field7b = null;
+ field core::int? field8a = null;
+ field core::int? field8b = null;
+ field self::G<self::Class<dynamic>>? field1c = null;
+ field self::G<self::Class<dynamic>>? field1d = null;
+ field self::G<dynamic>? field2c = null;
+ field self::G<dynamic>? field2d = null;
+ field self::G<self::Class<dynamic>>? field3c = null;
+ field self::G<self::Class<dynamic>>? field3d = null;
+ field self::G<self::Class<dynamic>>? field4c = null;
+ field self::G<self::Class<dynamic>>? field4d = null;
+ field self::G<self::ConcreteClass>? field5c = null;
+ field self::G<self::ConcreteClass>? field5d = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6c = null;
+ field self::G<self::Class<self::ConcreteClass>>? field6d = null;
+ field self::G<core::Object>? field7c = null;
+ field self::G<core::Object>? field8d = null;
+ field self::G<core::int>? field8c = null;
+ field self::G<core::int>? field7d = null;
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+extension Extension1 on core::int {
+ static field field1a = self::Extension1|field1a;
+ static field field1b = self::Extension1|field1b;
+ static field field2a = self::Extension1|field2a;
+ static field field2b = self::Extension1|field2b;
+ static field field3a = self::Extension1|field3a;
+ static field field3b = self::Extension1|field3b;
+ static field field4a = self::Extension1|field4a;
+ static field field4b = self::Extension1|field4b;
+ static field field5a = self::Extension1|field5a;
+ static field field5b = self::Extension1|field5b;
+ static field field6a = self::Extension1|field6a;
+ static field field6b = self::Extension1|field6b;
+ static field field7a = self::Extension1|field7a;
+ static field field7b = self::Extension1|field7b;
+ static field field8a = self::Extension1|field8a;
+ static field field8b = self::Extension1|field8b;
+ static field field1c = self::Extension1|field1c;
+ static field field1d = self::Extension1|field1d;
+ static field field2c = self::Extension1|field2c;
+ static field field2d = self::Extension1|field2d;
+ static field field3c = self::Extension1|field3c;
+ static field field3d = self::Extension1|field3d;
+ static field field4c = self::Extension1|field4c;
+ static field field4d = self::Extension1|field4d;
+ static field field5c = self::Extension1|field5c;
+ static field field5d = self::Extension1|field5d;
+ static field field6c = self::Extension1|field6c;
+ static field field6d = self::Extension1|field6d;
+ static field field7c = self::Extension1|field7c;
+ static field field8d = self::Extension1|field8d;
+ static field field8c = self::Extension1|field8c;
+ static field field7d = self::Extension1|field7d;
+}
+static field self::Class<dynamic>? field1a;
+static field self::Class<dynamic>? field1b;
+static field dynamic field2a;
+static field dynamic field2b;
+static field self::Class<dynamic>? field3a;
+static field self::Class<dynamic>? field3b;
+static field self::Class<dynamic>? field4a;
+static field self::Class<dynamic>? field4b;
+static field self::ConcreteClass? field5a;
+static field self::ConcreteClass? field5b;
+static field self::Class<self::ConcreteClass>? field6a;
+static field self::Class<self::ConcreteClass>? field6b;
+static field core::Object? field7a;
+static field core::Object? field7b;
+static field core::int? field8a;
+static field core::int? field8b;
+static field self::G<self::Class<dynamic>>? field1c;
+static field self::G<self::Class<dynamic>>? field1d;
+static field self::G<dynamic>? field2c;
+static field self::G<dynamic>? field2d;
+static field self::G<self::Class<dynamic>>? field3c;
+static field self::G<self::Class<dynamic>>? field3d;
+static field self::G<self::Class<dynamic>>? field4c;
+static field self::G<self::Class<dynamic>>? field4d;
+static field self::G<self::ConcreteClass>? field5c;
+static field self::G<self::ConcreteClass>? field5d;
+static field self::G<self::Class<self::ConcreteClass>>? field6c;
+static field self::G<self::Class<self::ConcreteClass>>? field6d;
+static field self::G<core::Object>? field7c;
+static field self::G<core::Object>? field8d;
+static field self::G<core::int>? field8c;
+static field self::G<core::int>? field7d;
+static field self::Class<dynamic>? Extension1|field1a;
+static field self::Class<dynamic>? Extension1|field1b;
+static field dynamic Extension1|field2a;
+static field dynamic Extension1|field2b;
+static field self::Class<dynamic>? Extension1|field3a;
+static field self::Class<dynamic>? Extension1|field3b;
+static field self::Class<dynamic>? Extension1|field4a;
+static field self::Class<dynamic>? Extension1|field4b;
+static field self::ConcreteClass? Extension1|field5a;
+static field self::ConcreteClass? Extension1|field5b;
+static field self::Class<self::ConcreteClass>? Extension1|field6a;
+static field self::Class<self::ConcreteClass>? Extension1|field6b;
+static field core::Object? Extension1|field7a;
+static field core::Object? Extension1|field7b;
+static field core::int? Extension1|field8a;
+static field core::int? Extension1|field8b;
+static field self::G<self::Class<dynamic>>? Extension1|field1c;
+static field self::G<self::Class<dynamic>>? Extension1|field1d;
+static field self::G<dynamic>? Extension1|field2c;
+static field self::G<dynamic>? Extension1|field2d;
+static field self::G<self::Class<dynamic>>? Extension1|field3c;
+static field self::G<self::Class<dynamic>>? Extension1|field3d;
+static field self::G<self::Class<dynamic>>? Extension1|field4c;
+static field self::G<self::Class<dynamic>>? Extension1|field4d;
+static field self::G<self::ConcreteClass>? Extension1|field5c;
+static field self::G<self::ConcreteClass>? Extension1|field5d;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6c;
+static field self::G<self::Class<self::ConcreteClass>>? Extension1|field6d;
+static field self::G<core::Object>? Extension1|field7c;
+static field self::G<core::Object>? Extension1|field8d;
+static field self::G<core::int>? Extension1|field8c;
+static field self::G<core::int>? Extension1|field7d;
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart b/pkg/front_end/testcases/general/bounds_instances.dart
new file mode 100644
index 0000000..b583f06
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart
@@ -0,0 +1,51 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = Class1;
+
+class G<X extends Class<X>> {}
+
+class Class1 {}
+
+test() {
+ new F(); // Error
+ new F<dynamic>(); // Error
+ new F<Class>(); // Error
+ new F<Class<dynamic>>(); // Error
+ new F<ConcreteClass>(); // Ok
+ new F<Class<ConcreteClass>>(); // Ok
+ new F<Object>(); // Error
+ new F<int>(); // Error
+ new G(); // Error
+ new G<dynamic>(); // Error
+ new G<Class>(); // Error
+ new G<Class<dynamic>>(); // Error
+ new G<ConcreteClass>(); // Ok
+ new G<Class<ConcreteClass>>(); // Ok
+ new G<Object>(); // Error
+ new G<int>(); // Error
+
+ F.new; // Ok
+ F<dynamic>.new; // Ok
+ F<Class>.new; // Ok
+ F<Class<dynamic>>.new; // Ok
+ F<ConcreteClass>.new; // Ok
+ F<Class<ConcreteClass>>.new; // Ok
+ F<Object>.new; // Error
+ F<int>.new; // Error
+ G.new; // Ok
+ G<dynamic>.new; // Error
+ G<Class>.new; // Error
+ G<Class<dynamic>>.new; // Error
+ G<ConcreteClass>.new; // Ok
+ G<Class<ConcreteClass>>.new; // Ok
+ G<Object>.new; // Error
+ G<int>.new; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline.expect
new file mode 100644
index 0000000..b507840
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline.expect
@@ -0,0 +1,12 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = Class1;
+
+class G<X extends Class<X>> {}
+
+class Class1 {}
+
+test() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..731451e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart.textual_outline_modelled.expect
@@ -0,0 +1,11 @@
+class Class<T> {}
+
+class Class1 {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+test() {}
+typedef F<X extends Class<X>> = Class1;
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart.weak.expect b/pkg/front_end/testcases/general/bounds_instances.dart.weak.expect
new file mode 100644
index 0000000..d236cbc
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart.weak.expect
@@ -0,0 +1,244 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:17:7: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<dynamic>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:18:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Class>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:19:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Class<dynamic>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:22:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Object>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:23:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<int>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:25:7: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<dynamic>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:26:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Class>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:27:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Class<dynamic>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:30:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Object>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:31:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<int>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:24:7: Error: Inferred type argument 'Class<Object?>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'Object' is from 'dart:core'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// new G(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:42:3: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<dynamic>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:43:3: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Class>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:44:3: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Class<dynamic>>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:47:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:48:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:16:7: Error: Inferred type argument 'Class<Object?>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'Object' is from 'dart:core'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// new F(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:39:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>.new; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:40:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>.new; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<unrelated X extends self::Class<X> = self::Class<dynamic>> = self::Class1;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::G::•<self::Class<core::Object?>>();
+ new self::G::•<dynamic>();
+ new self::G::•<self::Class<dynamic>>();
+ new self::G::•<self::Class<dynamic>>();
+ new self::G::•<self::ConcreteClass>();
+ new self::G::•<self::Class<self::ConcreteClass>>();
+ new self::G::•<core::Object>();
+ new self::G::•<core::int>();
+ #C1;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C3;
+ #C4;
+ #C5;
+ #C5;
+ #C6;
+ #C7;
+ #C8;
+ #C9;
+}
+static method main() → dynamic {}
+static method _#F#new#tearOff<unrelated X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class1
+ return new self::Class1::•();
+
+constants {
+ #C1 = static-tearoff self::_#F#new#tearOff
+ #C2 = constructor-tearoff self::Class1::•
+ #C3 = constructor-tearoff self::G::•
+ #C4 = instantiation #C3 <dynamic>
+ #C5 = instantiation #C3 <self::Class<dynamic>*>
+ #C6 = instantiation #C3 <self::ConcreteClass*>
+ #C7 = instantiation #C3 <self::Class<self::ConcreteClass*>*>
+ #C8 = instantiation #C3 <core::Object*>
+ #C9 = instantiation #C3 <core::int*>
+}
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_instances.dart.weak.modular.expect
new file mode 100644
index 0000000..d236cbc
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart.weak.modular.expect
@@ -0,0 +1,244 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:17:7: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<dynamic>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:18:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Class>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:19:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Class<dynamic>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:22:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<Object>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:23:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new F<int>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:25:7: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<dynamic>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:26:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Class>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:27:7: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Class<dynamic>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:30:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<Object>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:31:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new G<int>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:24:7: Error: Inferred type argument 'Class<Object?>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'Object' is from 'dart:core'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// new G(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:42:3: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<dynamic>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:43:3: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Class>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:44:3: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Class<dynamic>>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:47:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:48:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G<X> Function<X extends Class<X>>()'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>.new; // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:16:7: Error: Inferred type argument 'Class<Object?>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// - 'Object' is from 'dart:core'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// new F(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:39:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>.new; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_instances.dart:40:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_instances.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>.new; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_instances.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class1;
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<unrelated X extends self::Class<X> = self::Class<dynamic>> = self::Class1;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::Class1::•();
+ new self::G::•<self::Class<core::Object?>>();
+ new self::G::•<dynamic>();
+ new self::G::•<self::Class<dynamic>>();
+ new self::G::•<self::Class<dynamic>>();
+ new self::G::•<self::ConcreteClass>();
+ new self::G::•<self::Class<self::ConcreteClass>>();
+ new self::G::•<core::Object>();
+ new self::G::•<core::int>();
+ #C1;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C2;
+ #C3;
+ #C4;
+ #C5;
+ #C5;
+ #C6;
+ #C7;
+ #C8;
+ #C9;
+}
+static method main() → dynamic {}
+static method _#F#new#tearOff<unrelated X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class1
+ return new self::Class1::•();
+
+constants {
+ #C1 = static-tearoff self::_#F#new#tearOff
+ #C2 = constructor-tearoff self::Class1::•
+ #C3 = constructor-tearoff self::G::•
+ #C4 = instantiation #C3 <dynamic>
+ #C5 = instantiation #C3 <self::Class<dynamic>*>
+ #C6 = instantiation #C3 <self::ConcreteClass*>
+ #C7 = instantiation #C3 <self::Class<self::ConcreteClass*>*>
+ #C8 = instantiation #C3 <core::Object*>
+ #C9 = instantiation #C3 <core::int*>
+}
diff --git a/pkg/front_end/testcases/general/bounds_instances.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_instances.dart.weak.outline.expect
new file mode 100644
index 0000000..714445f
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_instances.dart.weak.outline.expect
@@ -0,0 +1,27 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<unrelated X extends self::Class<X> = self::Class<dynamic>> = self::Class1;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ ;
+}
+static method test() → dynamic
+ ;
+static method main() → dynamic
+ ;
+static method _#F#new#tearOff<unrelated X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class1
+ return new self::Class1::•();
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart b/pkg/front_end/testcases/general/bounds_literals.dart
new file mode 100644
index 0000000..1e9e2aa
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart
@@ -0,0 +1,58 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+test() {
+ <F, F<dynamic>>{}; // Ok
+ <F<Class>, F<Class<dynamic>>>{}; // Ok
+ <F<ConcreteClass>, F<Class<ConcreteClass>>>{}; // Ok
+ <F<Object>, F<int>>{}; // Error
+ <G, G<dynamic>>{}; // Ok
+ <G<Class>, G<Class<dynamic>>>{}; // Ok
+ <G<ConcreteClass>, G<Class<ConcreteClass>>>{}; // Ok
+ <G<Object>, G<int>>{}; // Error
+
+ <F>{}; // Ok
+ <F<dynamic>>{}; // Ok
+ <F<Class>>{}; // Ok
+ <F<Class<dynamic>>>{}; // Ok
+ <F<Object>>{}; // Error
+ <F<int>>{}; // Error
+ <F<ConcreteClass>>{}; // Ok
+ <F<Class<ConcreteClass>>>{}; // Ok
+ <G>{}; // Ok
+ <G<dynamic>>{}; // Ok
+ <G<Class>>{}; // Ok
+ <G<Class<dynamic>>>{}; // Ok
+ <G<ConcreteClass>>{}; // Ok
+ <G<Class<ConcreteClass>>>{}; // Ok
+ <G<Object>>{}; // Error
+ <G<int>>{}; // Error
+
+ <F>[]; // Ok
+ <F<dynamic>>[]; // Ok
+ <F<Class>>[]; // Ok
+ <F<Class<dynamic>>>[]; // Ok
+ <F<ConcreteClass>>[]; // Ok
+ <F<Class<ConcreteClass>>>[]; // Ok
+ <F<Object>>[]; // Error
+ <F<int>>[]; // Error
+ <G>[]; // Ok
+ <G<dynamic>>[]; // Ok
+ <G<Class>>[]; // Ok
+ <G<Class<dynamic>>>[]; // Ok
+ <G<ConcreteClass>>[]; // Ok
+ <G<Class<ConcreteClass>>>[]; // Ok
+ <G<Object>>[]; // Error
+ <G<int>>[]; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline.expect
new file mode 100644
index 0000000..903ffb2
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline.expect
@@ -0,0 +1,10 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+test() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..a5aa923
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.textual_outline_modelled.expect
@@ -0,0 +1,9 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+test() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.weak.expect b/pkg/front_end/testcases/general/bounds_literals.dart.weak.expect
new file mode 100644
index 0000000..fc49d81
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.weak.expect
@@ -0,0 +1,213 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:27:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:28:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:37:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:38:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:46:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:47:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:54:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:55:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ <self::Class<dynamic>, dynamic>{};
+ <self::Class<dynamic>, self::Class<dynamic>>{};
+ <self::ConcreteClass, self::Class<self::ConcreteClass>>{};
+ <core::Object, core::int>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>>{};
+ <self::G<core::Object>, self::G<core::int>>{};
+ block {
+ final core::Set<self::Class<dynamic>> #t1 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t1;
+ block {
+ final core::Set<dynamic> #t2 = col::LinkedHashSet::•<dynamic>();
+ } =>#t2;
+ block {
+ final core::Set<self::Class<dynamic>> #t3 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t3;
+ block {
+ final core::Set<self::Class<dynamic>> #t4 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t4;
+ block {
+ final core::Set<core::Object> #t5 = col::LinkedHashSet::•<core::Object>();
+ } =>#t5;
+ block {
+ final core::Set<core::int> #t6 = col::LinkedHashSet::•<core::int>();
+ } =>#t6;
+ block {
+ final core::Set<self::ConcreteClass> #t7 = col::LinkedHashSet::•<self::ConcreteClass>();
+ } =>#t7;
+ block {
+ final core::Set<self::Class<self::ConcreteClass>> #t8 = col::LinkedHashSet::•<self::Class<self::ConcreteClass>>();
+ } =>#t8;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t9 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t9;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t10 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t10;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t11 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t11;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t12 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t12;
+ block {
+ final core::Set<self::G<self::ConcreteClass>> #t13 = col::LinkedHashSet::•<self::G<self::ConcreteClass>>();
+ } =>#t13;
+ block {
+ final core::Set<self::G<self::Class<self::ConcreteClass>>> #t14 = col::LinkedHashSet::•<self::G<self::Class<self::ConcreteClass>>>();
+ } =>#t14;
+ block {
+ final core::Set<self::G<core::Object>> #t15 = col::LinkedHashSet::•<self::G<core::Object>>();
+ } =>#t15;
+ block {
+ final core::Set<self::G<core::int>> #t16 = col::LinkedHashSet::•<self::G<core::int>>();
+ } =>#t16;
+ <self::Class<dynamic>>[];
+ <dynamic>[];
+ <self::Class<dynamic>>[];
+ <self::Class<dynamic>>[];
+ <self::ConcreteClass>[];
+ <self::Class<self::ConcreteClass>>[];
+ <core::Object>[];
+ <core::int>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::ConcreteClass>>[];
+ <self::G<self::Class<self::ConcreteClass>>>[];
+ <self::G<core::Object>>[];
+ <self::G<core::int>>[];
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_literals.dart.weak.modular.expect
new file mode 100644
index 0000000..fc49d81
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.weak.modular.expect
@@ -0,0 +1,213 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:27:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:28:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:37:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:38:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:46:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:47:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:54:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:55:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ <self::Class<dynamic>, dynamic>{};
+ <self::Class<dynamic>, self::Class<dynamic>>{};
+ <self::ConcreteClass, self::Class<self::ConcreteClass>>{};
+ <core::Object, core::int>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>>{};
+ <self::G<core::Object>, self::G<core::int>>{};
+ block {
+ final core::Set<self::Class<dynamic>> #t1 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t1;
+ block {
+ final core::Set<dynamic> #t2 = col::LinkedHashSet::•<dynamic>();
+ } =>#t2;
+ block {
+ final core::Set<self::Class<dynamic>> #t3 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t3;
+ block {
+ final core::Set<self::Class<dynamic>> #t4 = col::LinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t4;
+ block {
+ final core::Set<core::Object> #t5 = col::LinkedHashSet::•<core::Object>();
+ } =>#t5;
+ block {
+ final core::Set<core::int> #t6 = col::LinkedHashSet::•<core::int>();
+ } =>#t6;
+ block {
+ final core::Set<self::ConcreteClass> #t7 = col::LinkedHashSet::•<self::ConcreteClass>();
+ } =>#t7;
+ block {
+ final core::Set<self::Class<self::ConcreteClass>> #t8 = col::LinkedHashSet::•<self::Class<self::ConcreteClass>>();
+ } =>#t8;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t9 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t9;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t10 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t10;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t11 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t11;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t12 = col::LinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t12;
+ block {
+ final core::Set<self::G<self::ConcreteClass>> #t13 = col::LinkedHashSet::•<self::G<self::ConcreteClass>>();
+ } =>#t13;
+ block {
+ final core::Set<self::G<self::Class<self::ConcreteClass>>> #t14 = col::LinkedHashSet::•<self::G<self::Class<self::ConcreteClass>>>();
+ } =>#t14;
+ block {
+ final core::Set<self::G<core::Object>> #t15 = col::LinkedHashSet::•<self::G<core::Object>>();
+ } =>#t15;
+ block {
+ final core::Set<self::G<core::int>> #t16 = col::LinkedHashSet::•<self::G<core::int>>();
+ } =>#t16;
+ <self::Class<dynamic>>[];
+ <dynamic>[];
+ <self::Class<dynamic>>[];
+ <self::Class<dynamic>>[];
+ <self::ConcreteClass>[];
+ <self::Class<self::ConcreteClass>>[];
+ <core::Object>[];
+ <core::int>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::Class<dynamic>>>[];
+ <self::G<self::ConcreteClass>>[];
+ <self::G<self::Class<self::ConcreteClass>>>[];
+ <self::G<core::Object>>[];
+ <self::G<core::int>>[];
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_literals.dart.weak.outline.expect
new file mode 100644
index 0000000..3215dc6
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.weak.outline.expect
@@ -0,0 +1,21 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+static method test() → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_literals.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_literals.dart.weak.transformed.expect
new file mode 100644
index 0000000..5c630d7
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_literals.dart.weak.transformed.expect
@@ -0,0 +1,213 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:17:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>, F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:21:15: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>, G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:27:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:28:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:37:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:38:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>{}; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:46:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:47:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <F<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:54:4: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<Object>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_literals.dart:55:4: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// <G<int>>[]; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ <self::Class<dynamic>, dynamic>{};
+ <self::Class<dynamic>, self::Class<dynamic>>{};
+ <self::ConcreteClass, self::Class<self::ConcreteClass>>{};
+ <core::Object, core::int>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>>{};
+ <self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>>{};
+ <self::G<core::Object>, self::G<core::int>>{};
+ block {
+ final core::Set<self::Class<dynamic>> #t1 = new col::_CompactLinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t1;
+ block {
+ final core::Set<dynamic> #t2 = new col::_CompactLinkedHashSet::•<dynamic>();
+ } =>#t2;
+ block {
+ final core::Set<self::Class<dynamic>> #t3 = new col::_CompactLinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t3;
+ block {
+ final core::Set<self::Class<dynamic>> #t4 = new col::_CompactLinkedHashSet::•<self::Class<dynamic>>();
+ } =>#t4;
+ block {
+ final core::Set<core::Object> #t5 = new col::_CompactLinkedHashSet::•<core::Object>();
+ } =>#t5;
+ block {
+ final core::Set<core::int> #t6 = new col::_CompactLinkedHashSet::•<core::int>();
+ } =>#t6;
+ block {
+ final core::Set<self::ConcreteClass> #t7 = new col::_CompactLinkedHashSet::•<self::ConcreteClass>();
+ } =>#t7;
+ block {
+ final core::Set<self::Class<self::ConcreteClass>> #t8 = new col::_CompactLinkedHashSet::•<self::Class<self::ConcreteClass>>();
+ } =>#t8;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t9 = new col::_CompactLinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t9;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t10 = new col::_CompactLinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t10;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t11 = new col::_CompactLinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t11;
+ block {
+ final core::Set<self::G<self::Class<dynamic>>> #t12 = new col::_CompactLinkedHashSet::•<self::G<self::Class<dynamic>>>();
+ } =>#t12;
+ block {
+ final core::Set<self::G<self::ConcreteClass>> #t13 = new col::_CompactLinkedHashSet::•<self::G<self::ConcreteClass>>();
+ } =>#t13;
+ block {
+ final core::Set<self::G<self::Class<self::ConcreteClass>>> #t14 = new col::_CompactLinkedHashSet::•<self::G<self::Class<self::ConcreteClass>>>();
+ } =>#t14;
+ block {
+ final core::Set<self::G<core::Object>> #t15 = new col::_CompactLinkedHashSet::•<self::G<core::Object>>();
+ } =>#t15;
+ block {
+ final core::Set<self::G<core::int>> #t16 = new col::_CompactLinkedHashSet::•<self::G<core::int>>();
+ } =>#t16;
+ core::_GrowableList::•<self::Class<dynamic>>(0);
+ core::_GrowableList::•<dynamic>(0);
+ core::_GrowableList::•<self::Class<dynamic>>(0);
+ core::_GrowableList::•<self::Class<dynamic>>(0);
+ core::_GrowableList::•<self::ConcreteClass>(0);
+ core::_GrowableList::•<self::Class<self::ConcreteClass>>(0);
+ core::_GrowableList::•<core::Object>(0);
+ core::_GrowableList::•<core::int>(0);
+ core::_GrowableList::•<self::G<self::Class<dynamic>>>(0);
+ core::_GrowableList::•<self::G<self::Class<dynamic>>>(0);
+ core::_GrowableList::•<self::G<self::Class<dynamic>>>(0);
+ core::_GrowableList::•<self::G<self::Class<dynamic>>>(0);
+ core::_GrowableList::•<self::G<self::ConcreteClass>>(0);
+ core::_GrowableList::•<self::G<self::Class<self::ConcreteClass>>>(0);
+ core::_GrowableList::•<self::G<core::Object>>(0);
+ core::_GrowableList::•<self::G<core::int>>(0);
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart b/pkg/front_end/testcases/general/bounds_parameters.dart
new file mode 100644
index 0000000..98d74d7
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart
@@ -0,0 +1,135 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+void method1(
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+}) {
+ void local(
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+ }) {}
+ (
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+ }) {};
+}
+
+class Class1 {
+ Class1(
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+ });
+ void method2(
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+ }) {}
+}
+
+extension Extension1 on int {
+ void method3(
+ F t1, // Ok
+ F<dynamic> t2, // Ok
+ F<Class> t3, // Ok
+ F<Class<dynamic>> t4, // Ok
+ F<ConcreteClass> t5, // Ok
+ F<Class<ConcreteClass>> t6, // Ok
+ F<Object> t7, // Error
+ F<int> t8, // Error
+ {
+ required G s1, // Ok
+ required G<dynamic> s2, // Ok
+ required G<Class> s3, // Ok
+ required G<Class<dynamic>> s4, // Ok
+ required G<ConcreteClass> s5, // Ok
+ required G<Class<ConcreteClass>> s6, // Ok
+ required G<Object> s7, // Error
+ required G<int> s8, // Error
+ }) {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline.expect
new file mode 100644
index 0000000..27b2f52
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline.expect
@@ -0,0 +1,88 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+void method1(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+}) {}
+
+class Class1 {
+ Class1(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ });
+ void method2(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ }) {}
+}
+
+extension Extension1 on int {
+ void method3(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ }) {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..443433c
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,86 @@
+class Class<T> {}
+
+class Class1 {
+ Class1(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ });
+ void method2(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ }) {}
+}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+extension Extension1 on int {
+ void method3(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+ }) {}
+}
+
+main() {}
+typedef F<X extends Class<X>> = X;
+void method1(
+ F t1,
+ F<dynamic> t2,
+ F<Class> t3,
+ F<Class<dynamic>> t4,
+ F<ConcreteClass> t5,
+ F<Class<ConcreteClass>> t6,
+ F<Object> t7,
+ F<int> t8, {
+ required G s1,
+ required G<dynamic> s2,
+ required G<Class> s3,
+ required G<Class<dynamic>> s4,
+ required G<ConcreteClass> s5,
+ required G<Class<ConcreteClass>> s6,
+ required G<Object> s7,
+ required G<int> s8,
+}) {}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.weak.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.expect
new file mode 100644
index 0000000..da70b89
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:29:12: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:30:12: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:99:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:100:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:108:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:109:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:80:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:81:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:89:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:90:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:121:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:122:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:130:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:131:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:39:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:40:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:48:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:49:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:58:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:59:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:67:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:68:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ constructor •(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → self::Class1
+ : super core::Object::•()
+ ;
+ method method2(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+}
+extension Extension1 on core::int {
+ method method3 = self::Extension1|method3;
+ tearoff method3 = self::Extension1|get#method3;
+}
+static method method1(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {
+ function local(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+ (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → Null {};
+}
+static method Extension1|method3(lowered final core::int #this, self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+static method Extension1|get#method3(lowered final core::int #this) → (self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, {s1: self::G<self::Class<dynamic>>, s2: self::G<dynamic>, s3: self::G<self::Class<dynamic>>, s4: self::G<self::Class<dynamic>>, s5: self::G<self::ConcreteClass>, s6: self::G<self::Class<self::ConcreteClass>>, s7: self::G<core::Object>, s8: self::G<core::int>}) → void
+ return (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {self::G<self::Class<dynamic>> s1 = #C1, self::G<dynamic> s2 = #C1, self::G<self::Class<dynamic>> s3 = #C1, self::G<self::Class<dynamic>> s4 = #C1, self::G<self::ConcreteClass> s5 = #C1, self::G<self::Class<self::ConcreteClass>> s6 = #C1, self::G<core::Object> s7 = #C1, self::G<core::int> s8 = #C1}) → void => self::Extension1|method3(#this, t1, t2, t3, t4, t5, t6, t7, t8, s1: s1, s2: s2, s3: s3, s4: s4, s5: s5, s6: s6, s7: s7, s8: s8);
+static method main() → dynamic {}
+
+constants {
+ #C1 = null
+}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.modular.expect
new file mode 100644
index 0000000..da70b89
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.modular.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:29:12: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:30:12: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:99:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:100:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:108:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:109:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:80:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:81:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:89:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:90:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:121:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:122:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:130:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:131:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:39:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:40:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:48:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:49:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:58:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:59:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:67:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:68:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ constructor •(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → self::Class1
+ : super core::Object::•()
+ ;
+ method method2(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+}
+extension Extension1 on core::int {
+ method method3 = self::Extension1|method3;
+ tearoff method3 = self::Extension1|get#method3;
+}
+static method method1(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {
+ function local(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+ (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → Null {};
+}
+static method Extension1|method3(lowered final core::int #this, self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+static method Extension1|get#method3(lowered final core::int #this) → (self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, {s1: self::G<self::Class<dynamic>>, s2: self::G<dynamic>, s3: self::G<self::Class<dynamic>>, s4: self::G<self::Class<dynamic>>, s5: self::G<self::ConcreteClass>, s6: self::G<self::Class<self::ConcreteClass>>, s7: self::G<core::Object>, s8: self::G<core::int>}) → void
+ return (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {self::G<self::Class<dynamic>> s1 = #C1, self::G<dynamic> s2 = #C1, self::G<self::Class<dynamic>> s3 = #C1, self::G<self::Class<dynamic>> s4 = #C1, self::G<self::ConcreteClass> s5 = #C1, self::G<self::Class<self::ConcreteClass>> s6 = #C1, self::G<core::Object> s7 = #C1, self::G<core::int> s8 = #C1}) → void => self::Extension1|method3(#this, t1, t2, t3, t4, t5, t6, t7, t8, s1: s1, s2: s2, s3: s3, s4: s4, s5: s5, s6: s6, s7: s7, s8: s8);
+static method main() → dynamic {}
+
+constants {
+ #C1 = null
+}
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.outline.expect
new file mode 100644
index 0000000..841b07a
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.outline.expect
@@ -0,0 +1,190 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:29:12: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:30:12: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:99:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:100:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:108:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:109:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:80:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:81:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:89:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:90:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:121:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:122:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:130:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:131:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1 extends core::Object {
+ constructor •(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = null, required self::G<dynamic> s2 = null, required self::G<self::Class<dynamic>> s3 = null, required self::G<self::Class<dynamic>> s4 = null, required self::G<self::ConcreteClass> s5 = null, required self::G<self::Class<self::ConcreteClass>> s6 = null, required self::G<core::Object> s7 = null, required self::G<core::int> s8 = null}) → self::Class1
+ ;
+ method method2(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = null, required self::G<dynamic> s2 = null, required self::G<self::Class<dynamic>> s3 = null, required self::G<self::Class<dynamic>> s4 = null, required self::G<self::ConcreteClass> s5 = null, required self::G<self::Class<self::ConcreteClass>> s6 = null, required self::G<core::Object> s7 = null, required self::G<core::int> s8 = null}) → void
+ ;
+}
+extension Extension1 on core::int {
+ method method3 = self::Extension1|method3;
+ tearoff method3 = self::Extension1|get#method3;
+}
+static method method1(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1, required self::G<dynamic> s2, required self::G<self::Class<dynamic>> s3, required self::G<self::Class<dynamic>> s4, required self::G<self::ConcreteClass> s5, required self::G<self::Class<self::ConcreteClass>> s6, required self::G<core::Object> s7, required self::G<core::int> s8}) → void
+ ;
+static method Extension1|method3(lowered final core::int #this, self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1, required self::G<dynamic> s2, required self::G<self::Class<dynamic>> s3, required self::G<self::Class<dynamic>> s4, required self::G<self::ConcreteClass> s5, required self::G<self::Class<self::ConcreteClass>> s6, required self::G<core::Object> s7, required self::G<core::int> s8}) → void
+ ;
+static method Extension1|get#method3(lowered final core::int #this) → (self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, {s1: self::G<self::Class<dynamic>>, s2: self::G<dynamic>, s3: self::G<self::Class<dynamic>>, s4: self::G<self::Class<dynamic>>, s5: self::G<self::ConcreteClass>, s6: self::G<self::Class<self::ConcreteClass>>, s7: self::G<core::Object>, s8: self::G<core::int>}) → void
+ return (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {self::G<self::Class<dynamic>> s1, self::G<dynamic> s2, self::G<self::Class<dynamic>> s3, self::G<self::Class<dynamic>> s4, self::G<self::ConcreteClass> s5, self::G<self::Class<self::ConcreteClass>> s6, self::G<core::Object> s7, self::G<core::int> s8}) → void => self::Extension1|method3(#this, t1, t2, t3, t4, t5, t6, t7, t8, s1: s1, s2: s2, s3: s3, s4: s4, s5: s5, s6: s6, s7: s7, s8: s8);
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_parameters.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.transformed.expect
new file mode 100644
index 0000000..da70b89
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_parameters.dart.weak.transformed.expect
@@ -0,0 +1,273 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:29:12: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:30:12: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:99:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:100:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:108:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:109:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:80:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:81:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:89:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:90:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:121:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:122:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:130:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:131:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:39:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:40:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:48:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:49:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:58:5: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:59:5: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:67:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<Object> s7, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_parameters.dart:68:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// required G<int> s8, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ constructor •(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → self::Class1
+ : super core::Object::•()
+ ;
+ method method2(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+}
+extension Extension1 on core::int {
+ method method3 = self::Extension1|method3;
+ tearoff method3 = self::Extension1|get#method3;
+}
+static method method1(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {
+ function local(self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+ (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → Null {};
+}
+static method Extension1|method3(lowered final core::int #this, self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {required self::G<self::Class<dynamic>> s1 = #C1, required self::G<dynamic> s2 = #C1, required self::G<self::Class<dynamic>> s3 = #C1, required self::G<self::Class<dynamic>> s4 = #C1, required self::G<self::ConcreteClass> s5 = #C1, required self::G<self::Class<self::ConcreteClass>> s6 = #C1, required self::G<core::Object> s7 = #C1, required self::G<core::int> s8 = #C1}) → void {}
+static method Extension1|get#method3(lowered final core::int #this) → (self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, {s1: self::G<self::Class<dynamic>>, s2: self::G<dynamic>, s3: self::G<self::Class<dynamic>>, s4: self::G<self::Class<dynamic>>, s5: self::G<self::ConcreteClass>, s6: self::G<self::Class<self::ConcreteClass>>, s7: self::G<core::Object>, s8: self::G<core::int>}) → void
+ return (self::Class<dynamic> t1, dynamic t2, self::Class<dynamic> t3, self::Class<dynamic> t4, self::ConcreteClass t5, self::Class<self::ConcreteClass> t6, core::Object t7, core::int t8, {self::G<self::Class<dynamic>> s1 = #C1, self::G<dynamic> s2 = #C1, self::G<self::Class<dynamic>> s3 = #C1, self::G<self::Class<dynamic>> s4 = #C1, self::G<self::ConcreteClass> s5 = #C1, self::G<self::Class<self::ConcreteClass>> s6 = #C1, self::G<core::Object> s7 = #C1, self::G<core::int> s8 = #C1}) → void => self::Extension1|method3(#this, t1, t2, t3, t4, t5, t6, t7, t8, s1: s1, s2: s2, s3: s3, s4: s4, s5: s5, s6: s6, s7: s7, s8: s8);
+static method main() → dynamic {}
+
+constants {
+ #C1 = null
+}
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart b/pkg/front_end/testcases/general/bounds_return_types.dart
new file mode 100644
index 0000000..54e4b2f
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart
@@ -0,0 +1,87 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+F t1() => throw ''; // Ok
+F<dynamic> t2() => throw ''; // Ok
+F<Class> t3() => throw ''; // Ok
+F<Class<dynamic>> t4() => throw ''; // Ok
+F<ConcreteClass> t5() => throw ''; // Ok
+F<Class<ConcreteClass>> t6() => throw ''; // Ok
+F<Object> t7() => throw ''; // Error
+F<int> t8() => throw ''; // Error
+G s1() => throw ''; // Ok
+G<dynamic> s2() => throw ''; // Ok
+G<Class> s3() => throw ''; // Ok
+G<Class<dynamic>> s4() => throw ''; // Ok
+G<ConcreteClass> s5() => throw ''; // Ok
+G<Class<ConcreteClass>> s6() => throw ''; // Ok
+G<Object> s7() => throw ''; // Error
+G<int> s8() => throw ''; // Error
+
+method1() {
+ F t1() => throw ''; // Ok
+ F<dynamic> t2() => throw ''; // Ok
+ F<Class> t3() => throw ''; // Ok
+ F<Class<dynamic>> t4() => throw ''; // Ok
+ F<ConcreteClass> t5() => throw ''; // Ok
+ F<Class<ConcreteClass>> t6() => throw ''; // Ok
+ F<Object> t7() => throw ''; // Error
+ F<int> t8() => throw ''; // Error
+ G s1() => throw ''; // Ok
+ G<dynamic> s2() => throw ''; // Ok
+ G<Class> s3() => throw ''; // Ok
+ G<Class<dynamic>> s4() => throw ''; // Ok
+ G<ConcreteClass> s5() => throw ''; // Ok
+ G<Class<ConcreteClass>> s6() => throw ''; // Ok
+ G<Object> s7() => throw ''; // Error
+ G<int> s8() => throw ''; // Error
+}
+
+class Class1 {
+ F t1() => throw ''; // Ok
+ F<dynamic> t2() => throw ''; // Ok
+ F<Class> t3() => throw ''; // Ok
+ F<Class<dynamic>> t4() => throw ''; // Ok
+ F<ConcreteClass> t5() => throw ''; // Ok
+ F<Class<ConcreteClass>> t6() => throw ''; // Ok
+ F<Object> t7() => throw ''; // Error
+ F<int> t8() => throw ''; // Error
+ G s1() => throw ''; // Ok
+ G<dynamic> s2() => throw ''; // Ok
+ G<Class> s3() => throw ''; // Ok
+ G<Class<dynamic>> s4() => throw ''; // Ok
+ G<ConcreteClass> s5() => throw ''; // Ok
+ G<Class<ConcreteClass>> s6() => throw ''; // Ok
+ G<Object> s7() => throw ''; // Error
+ G<int> s8() => throw ''; // Error
+}
+
+extension Extension1 on int {
+ F t1() => throw ''; // Ok
+ F<dynamic> t2() => throw ''; // Ok
+ F<Class> t3() => throw ''; // Ok
+ F<Class<dynamic>> t4() => throw ''; // Ok
+ F<ConcreteClass> t5() => throw ''; // Ok
+ F<Class<ConcreteClass>> t6() => throw ''; // Ok
+ F<Object> t7() => throw ''; // Error
+ F<int> t8() => throw ''; // Error
+ G s1() => throw ''; // Ok
+ G<dynamic> s2() => throw ''; // Ok
+ G<Class> s3() => throw ''; // Ok
+ G<Class<dynamic>> s4() => throw ''; // Ok
+ G<ConcreteClass> s5() => throw ''; // Ok
+ G<Class<ConcreteClass>> s6() => throw ''; // Ok
+ G<Object> s7() => throw ''; // Error
+ G<int> s8() => throw ''; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline.expect
new file mode 100644
index 0000000..0e5dcfa
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline.expect
@@ -0,0 +1,65 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+F t1() => throw '';
+F<dynamic> t2() => throw '';
+F<Class> t3() => throw '';
+F<Class<dynamic>> t4() => throw '';
+F<ConcreteClass> t5() => throw '';
+F<Class<ConcreteClass>> t6() => throw '';
+F<Object> t7() => throw '';
+F<int> t8() => throw '';
+G s1() => throw '';
+G<dynamic> s2() => throw '';
+G<Class> s3() => throw '';
+G<Class<dynamic>> s4() => throw '';
+G<ConcreteClass> s5() => throw '';
+G<Class<ConcreteClass>> s6() => throw '';
+G<Object> s7() => throw '';
+G<int> s8() => throw '';
+method1() {}
+
+class Class1 {
+ F t1() => throw '';
+ F<dynamic> t2() => throw '';
+ F<Class> t3() => throw '';
+ F<Class<dynamic>> t4() => throw '';
+ F<ConcreteClass> t5() => throw '';
+ F<Class<ConcreteClass>> t6() => throw '';
+ F<Object> t7() => throw '';
+ F<int> t8() => throw '';
+ G s1() => throw '';
+ G<dynamic> s2() => throw '';
+ G<Class> s3() => throw '';
+ G<Class<dynamic>> s4() => throw '';
+ G<ConcreteClass> s5() => throw '';
+ G<Class<ConcreteClass>> s6() => throw '';
+ G<Object> s7() => throw '';
+ G<int> s8() => throw '';
+}
+
+extension Extension1 on int {
+ F t1() => throw '';
+ F<dynamic> t2() => throw '';
+ F<Class> t3() => throw '';
+ F<Class<dynamic>> t4() => throw '';
+ F<ConcreteClass> t5() => throw '';
+ F<Class<ConcreteClass>> t6() => throw '';
+ F<Object> t7() => throw '';
+ F<int> t8() => throw '';
+ G s1() => throw '';
+ G<dynamic> s2() => throw '';
+ G<Class> s3() => throw '';
+ G<Class<dynamic>> s4() => throw '';
+ G<ConcreteClass> s5() => throw '';
+ G<Class<ConcreteClass>> s6() => throw '';
+ G<Object> s7() => throw '';
+ G<int> s8() => throw '';
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..d6ea412
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.textual_outline_modelled.expect
@@ -0,0 +1,64 @@
+F<Class<ConcreteClass>> t6() => throw '';
+F<Class<dynamic>> t4() => throw '';
+F<Class> t3() => throw '';
+F<ConcreteClass> t5() => throw '';
+F<Object> t7() => throw '';
+F<dynamic> t2() => throw '';
+F<int> t8() => throw '';
+F t1() => throw '';
+G<Class<ConcreteClass>> s6() => throw '';
+G<Class<dynamic>> s4() => throw '';
+G<Class> s3() => throw '';
+G<ConcreteClass> s5() => throw '';
+G<Object> s7() => throw '';
+G<dynamic> s2() => throw '';
+G<int> s8() => throw '';
+G s1() => throw '';
+
+class Class<T> {}
+
+class Class1 {
+ F<Class<ConcreteClass>> t6() => throw '';
+ F<Class<dynamic>> t4() => throw '';
+ F<Class> t3() => throw '';
+ F<ConcreteClass> t5() => throw '';
+ F<Object> t7() => throw '';
+ F<dynamic> t2() => throw '';
+ F<int> t8() => throw '';
+ F t1() => throw '';
+ G<Class<ConcreteClass>> s6() => throw '';
+ G<Class<dynamic>> s4() => throw '';
+ G<Class> s3() => throw '';
+ G<ConcreteClass> s5() => throw '';
+ G<Object> s7() => throw '';
+ G<dynamic> s2() => throw '';
+ G<int> s8() => throw '';
+ G s1() => throw '';
+}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+extension Extension1 on int {
+ F<Class<ConcreteClass>> t6() => throw '';
+ F<Class<dynamic>> t4() => throw '';
+ F<Class> t3() => throw '';
+ F<ConcreteClass> t5() => throw '';
+ F<Object> t7() => throw '';
+ F<dynamic> t2() => throw '';
+ F<int> t8() => throw '';
+ F t1() => throw '';
+ G<Class<ConcreteClass>> s6() => throw '';
+ G<Class<dynamic>> s4() => throw '';
+ G<Class> s3() => throw '';
+ G<ConcreteClass> s5() => throw '';
+ G<Object> s7() => throw '';
+ G<dynamic> s2() => throw '';
+ G<int> s8() => throw '';
+ G s1() => throw '';
+}
+
+main() {}
+method1() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.weak.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.expect
new file mode 100644
index 0000000..6adeaf2
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.expect
@@ -0,0 +1,377 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:56:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:57:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:64:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:65:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:75:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:76:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:83:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:84:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+ method t1() → self::Class<dynamic>
+ return throw "";
+ method t2() → dynamic
+ return throw "";
+ method t3() → self::Class<dynamic>
+ return throw "";
+ method t4() → self::Class<dynamic>
+ return throw "";
+ method t5() → self::ConcreteClass
+ return throw "";
+ method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ method t7() → core::Object
+ return throw "";
+ method t8() → core::int
+ return throw "";
+ method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s2() → self::G<dynamic>
+ return throw "";
+ method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s5() → self::G<self::ConcreteClass>
+ return throw "";
+ method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ method s7() → self::G<core::Object>
+ return throw "";
+ method s8() → self::G<core::int>
+ return throw "";
+}
+extension Extension1 on core::int {
+ method t1 = self::Extension1|t1;
+ tearoff t1 = self::Extension1|get#t1;
+ method t2 = self::Extension1|t2;
+ tearoff t2 = self::Extension1|get#t2;
+ method t3 = self::Extension1|t3;
+ tearoff t3 = self::Extension1|get#t3;
+ method t4 = self::Extension1|t4;
+ tearoff t4 = self::Extension1|get#t4;
+ method t5 = self::Extension1|t5;
+ tearoff t5 = self::Extension1|get#t5;
+ method t6 = self::Extension1|t6;
+ tearoff t6 = self::Extension1|get#t6;
+ method t7 = self::Extension1|t7;
+ tearoff t7 = self::Extension1|get#t7;
+ method t8 = self::Extension1|t8;
+ tearoff t8 = self::Extension1|get#t8;
+ method s1 = self::Extension1|s1;
+ tearoff s1 = self::Extension1|get#s1;
+ method s2 = self::Extension1|s2;
+ tearoff s2 = self::Extension1|get#s2;
+ method s3 = self::Extension1|s3;
+ tearoff s3 = self::Extension1|get#s3;
+ method s4 = self::Extension1|s4;
+ tearoff s4 = self::Extension1|get#s4;
+ method s5 = self::Extension1|s5;
+ tearoff s5 = self::Extension1|get#s5;
+ method s6 = self::Extension1|s6;
+ tearoff s6 = self::Extension1|get#s6;
+ method s7 = self::Extension1|s7;
+ tearoff s7 = self::Extension1|get#s7;
+ method s8 = self::Extension1|s8;
+ tearoff s8 = self::Extension1|get#s8;
+}
+static method t1() → self::Class<dynamic>
+ return throw "";
+static method t2() → dynamic
+ return throw "";
+static method t3() → self::Class<dynamic>
+ return throw "";
+static method t4() → self::Class<dynamic>
+ return throw "";
+static method t5() → self::ConcreteClass
+ return throw "";
+static method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+static method t7() → core::Object
+ return throw "";
+static method t8() → core::int
+ return throw "";
+static method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s2() → self::G<dynamic>
+ return throw "";
+static method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s5() → self::G<self::ConcreteClass>
+ return throw "";
+static method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method s7() → self::G<core::Object>
+ return throw "";
+static method s8() → self::G<core::int>
+ return throw "";
+static method method1() → dynamic {
+ function t1() → self::Class<dynamic>
+ return throw "";
+ function t2() → dynamic
+ return throw "";
+ function t3() → self::Class<dynamic>
+ return throw "";
+ function t4() → self::Class<dynamic>
+ return throw "";
+ function t5() → self::ConcreteClass
+ return throw "";
+ function t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ function t7() → core::Object
+ return throw "";
+ function t8() → core::int
+ return throw "";
+ function s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s2() → self::G<dynamic>
+ return throw "";
+ function s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s5() → self::G<self::ConcreteClass>
+ return throw "";
+ function s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ function s7() → self::G<core::Object>
+ return throw "";
+ function s8() → self::G<core::int>
+ return throw "";
+}
+static method Extension1|t1(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t1(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t1(#this);
+static method Extension1|t2(lowered final core::int #this) → dynamic
+ return throw "";
+static method Extension1|get#t2(lowered final core::int #this) → () → dynamic
+ return () → dynamic => self::Extension1|t2(#this);
+static method Extension1|t3(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t3(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t3(#this);
+static method Extension1|t4(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t4(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t4(#this);
+static method Extension1|t5(lowered final core::int #this) → self::ConcreteClass
+ return throw "";
+static method Extension1|get#t5(lowered final core::int #this) → () → self::ConcreteClass
+ return () → self::ConcreteClass => self::Extension1|t5(#this);
+static method Extension1|t6(lowered final core::int #this) → self::Class<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#t6(lowered final core::int #this) → () → self::Class<self::ConcreteClass>
+ return () → self::Class<self::ConcreteClass> => self::Extension1|t6(#this);
+static method Extension1|t7(lowered final core::int #this) → core::Object
+ return throw "";
+static method Extension1|get#t7(lowered final core::int #this) → () → core::Object
+ return () → core::Object => self::Extension1|t7(#this);
+static method Extension1|t8(lowered final core::int #this) → core::int
+ return throw "";
+static method Extension1|get#t8(lowered final core::int #this) → () → core::int
+ return () → core::int => self::Extension1|t8(#this);
+static method Extension1|s1(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s1(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s1(#this);
+static method Extension1|s2(lowered final core::int #this) → self::G<dynamic>
+ return throw "";
+static method Extension1|get#s2(lowered final core::int #this) → () → self::G<dynamic>
+ return () → self::G<dynamic> => self::Extension1|s2(#this);
+static method Extension1|s3(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s3(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s3(#this);
+static method Extension1|s4(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s4(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s4(#this);
+static method Extension1|s5(lowered final core::int #this) → self::G<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#s5(lowered final core::int #this) → () → self::G<self::ConcreteClass>
+ return () → self::G<self::ConcreteClass> => self::Extension1|s5(#this);
+static method Extension1|s6(lowered final core::int #this) → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method Extension1|get#s6(lowered final core::int #this) → () → self::G<self::Class<self::ConcreteClass>>
+ return () → self::G<self::Class<self::ConcreteClass>> => self::Extension1|s6(#this);
+static method Extension1|s7(lowered final core::int #this) → self::G<core::Object>
+ return throw "";
+static method Extension1|get#s7(lowered final core::int #this) → () → self::G<core::Object>
+ return () → self::G<core::Object> => self::Extension1|s7(#this);
+static method Extension1|s8(lowered final core::int #this) → self::G<core::int>
+ return throw "";
+static method Extension1|get#s8(lowered final core::int #this) → () → self::G<core::int>
+ return () → self::G<core::int> => self::Extension1|s8(#this);
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.modular.expect
new file mode 100644
index 0000000..6adeaf2
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.modular.expect
@@ -0,0 +1,377 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:56:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:57:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:64:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:65:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:75:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:76:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:83:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:84:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+ method t1() → self::Class<dynamic>
+ return throw "";
+ method t2() → dynamic
+ return throw "";
+ method t3() → self::Class<dynamic>
+ return throw "";
+ method t4() → self::Class<dynamic>
+ return throw "";
+ method t5() → self::ConcreteClass
+ return throw "";
+ method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ method t7() → core::Object
+ return throw "";
+ method t8() → core::int
+ return throw "";
+ method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s2() → self::G<dynamic>
+ return throw "";
+ method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s5() → self::G<self::ConcreteClass>
+ return throw "";
+ method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ method s7() → self::G<core::Object>
+ return throw "";
+ method s8() → self::G<core::int>
+ return throw "";
+}
+extension Extension1 on core::int {
+ method t1 = self::Extension1|t1;
+ tearoff t1 = self::Extension1|get#t1;
+ method t2 = self::Extension1|t2;
+ tearoff t2 = self::Extension1|get#t2;
+ method t3 = self::Extension1|t3;
+ tearoff t3 = self::Extension1|get#t3;
+ method t4 = self::Extension1|t4;
+ tearoff t4 = self::Extension1|get#t4;
+ method t5 = self::Extension1|t5;
+ tearoff t5 = self::Extension1|get#t5;
+ method t6 = self::Extension1|t6;
+ tearoff t6 = self::Extension1|get#t6;
+ method t7 = self::Extension1|t7;
+ tearoff t7 = self::Extension1|get#t7;
+ method t8 = self::Extension1|t8;
+ tearoff t8 = self::Extension1|get#t8;
+ method s1 = self::Extension1|s1;
+ tearoff s1 = self::Extension1|get#s1;
+ method s2 = self::Extension1|s2;
+ tearoff s2 = self::Extension1|get#s2;
+ method s3 = self::Extension1|s3;
+ tearoff s3 = self::Extension1|get#s3;
+ method s4 = self::Extension1|s4;
+ tearoff s4 = self::Extension1|get#s4;
+ method s5 = self::Extension1|s5;
+ tearoff s5 = self::Extension1|get#s5;
+ method s6 = self::Extension1|s6;
+ tearoff s6 = self::Extension1|get#s6;
+ method s7 = self::Extension1|s7;
+ tearoff s7 = self::Extension1|get#s7;
+ method s8 = self::Extension1|s8;
+ tearoff s8 = self::Extension1|get#s8;
+}
+static method t1() → self::Class<dynamic>
+ return throw "";
+static method t2() → dynamic
+ return throw "";
+static method t3() → self::Class<dynamic>
+ return throw "";
+static method t4() → self::Class<dynamic>
+ return throw "";
+static method t5() → self::ConcreteClass
+ return throw "";
+static method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+static method t7() → core::Object
+ return throw "";
+static method t8() → core::int
+ return throw "";
+static method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s2() → self::G<dynamic>
+ return throw "";
+static method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s5() → self::G<self::ConcreteClass>
+ return throw "";
+static method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method s7() → self::G<core::Object>
+ return throw "";
+static method s8() → self::G<core::int>
+ return throw "";
+static method method1() → dynamic {
+ function t1() → self::Class<dynamic>
+ return throw "";
+ function t2() → dynamic
+ return throw "";
+ function t3() → self::Class<dynamic>
+ return throw "";
+ function t4() → self::Class<dynamic>
+ return throw "";
+ function t5() → self::ConcreteClass
+ return throw "";
+ function t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ function t7() → core::Object
+ return throw "";
+ function t8() → core::int
+ return throw "";
+ function s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s2() → self::G<dynamic>
+ return throw "";
+ function s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s5() → self::G<self::ConcreteClass>
+ return throw "";
+ function s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ function s7() → self::G<core::Object>
+ return throw "";
+ function s8() → self::G<core::int>
+ return throw "";
+}
+static method Extension1|t1(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t1(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t1(#this);
+static method Extension1|t2(lowered final core::int #this) → dynamic
+ return throw "";
+static method Extension1|get#t2(lowered final core::int #this) → () → dynamic
+ return () → dynamic => self::Extension1|t2(#this);
+static method Extension1|t3(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t3(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t3(#this);
+static method Extension1|t4(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t4(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t4(#this);
+static method Extension1|t5(lowered final core::int #this) → self::ConcreteClass
+ return throw "";
+static method Extension1|get#t5(lowered final core::int #this) → () → self::ConcreteClass
+ return () → self::ConcreteClass => self::Extension1|t5(#this);
+static method Extension1|t6(lowered final core::int #this) → self::Class<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#t6(lowered final core::int #this) → () → self::Class<self::ConcreteClass>
+ return () → self::Class<self::ConcreteClass> => self::Extension1|t6(#this);
+static method Extension1|t7(lowered final core::int #this) → core::Object
+ return throw "";
+static method Extension1|get#t7(lowered final core::int #this) → () → core::Object
+ return () → core::Object => self::Extension1|t7(#this);
+static method Extension1|t8(lowered final core::int #this) → core::int
+ return throw "";
+static method Extension1|get#t8(lowered final core::int #this) → () → core::int
+ return () → core::int => self::Extension1|t8(#this);
+static method Extension1|s1(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s1(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s1(#this);
+static method Extension1|s2(lowered final core::int #this) → self::G<dynamic>
+ return throw "";
+static method Extension1|get#s2(lowered final core::int #this) → () → self::G<dynamic>
+ return () → self::G<dynamic> => self::Extension1|s2(#this);
+static method Extension1|s3(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s3(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s3(#this);
+static method Extension1|s4(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s4(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s4(#this);
+static method Extension1|s5(lowered final core::int #this) → self::G<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#s5(lowered final core::int #this) → () → self::G<self::ConcreteClass>
+ return () → self::G<self::ConcreteClass> => self::Extension1|s5(#this);
+static method Extension1|s6(lowered final core::int #this) → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method Extension1|get#s6(lowered final core::int #this) → () → self::G<self::Class<self::ConcreteClass>>
+ return () → self::G<self::Class<self::ConcreteClass>> => self::Extension1|s6(#this);
+static method Extension1|s7(lowered final core::int #this) → self::G<core::Object>
+ return throw "";
+static method Extension1|get#s7(lowered final core::int #this) → () → self::G<core::Object>
+ return () → self::G<core::Object> => self::Extension1|s7(#this);
+static method Extension1|s8(lowered final core::int #this) → self::G<core::int>
+ return throw "";
+static method Extension1|get#s8(lowered final core::int #this) → () → self::G<core::int>
+ return () → self::G<core::int> => self::Extension1|s8(#this);
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.outline.expect
new file mode 100644
index 0000000..4d68a21
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.outline.expect
@@ -0,0 +1,304 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:56:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:57:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:64:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:65:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:75:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:76:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:83:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:84:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ ;
+ method t1() → self::Class<dynamic>
+ ;
+ method t2() → dynamic
+ ;
+ method t3() → self::Class<dynamic>
+ ;
+ method t4() → self::Class<dynamic>
+ ;
+ method t5() → self::ConcreteClass
+ ;
+ method t6() → self::Class<self::ConcreteClass>
+ ;
+ method t7() → core::Object
+ ;
+ method t8() → core::int
+ ;
+ method s1() → self::G<self::Class<dynamic>>
+ ;
+ method s2() → self::G<dynamic>
+ ;
+ method s3() → self::G<self::Class<dynamic>>
+ ;
+ method s4() → self::G<self::Class<dynamic>>
+ ;
+ method s5() → self::G<self::ConcreteClass>
+ ;
+ method s6() → self::G<self::Class<self::ConcreteClass>>
+ ;
+ method s7() → self::G<core::Object>
+ ;
+ method s8() → self::G<core::int>
+ ;
+}
+extension Extension1 on core::int {
+ method t1 = self::Extension1|t1;
+ tearoff t1 = self::Extension1|get#t1;
+ method t2 = self::Extension1|t2;
+ tearoff t2 = self::Extension1|get#t2;
+ method t3 = self::Extension1|t3;
+ tearoff t3 = self::Extension1|get#t3;
+ method t4 = self::Extension1|t4;
+ tearoff t4 = self::Extension1|get#t4;
+ method t5 = self::Extension1|t5;
+ tearoff t5 = self::Extension1|get#t5;
+ method t6 = self::Extension1|t6;
+ tearoff t6 = self::Extension1|get#t6;
+ method t7 = self::Extension1|t7;
+ tearoff t7 = self::Extension1|get#t7;
+ method t8 = self::Extension1|t8;
+ tearoff t8 = self::Extension1|get#t8;
+ method s1 = self::Extension1|s1;
+ tearoff s1 = self::Extension1|get#s1;
+ method s2 = self::Extension1|s2;
+ tearoff s2 = self::Extension1|get#s2;
+ method s3 = self::Extension1|s3;
+ tearoff s3 = self::Extension1|get#s3;
+ method s4 = self::Extension1|s4;
+ tearoff s4 = self::Extension1|get#s4;
+ method s5 = self::Extension1|s5;
+ tearoff s5 = self::Extension1|get#s5;
+ method s6 = self::Extension1|s6;
+ tearoff s6 = self::Extension1|get#s6;
+ method s7 = self::Extension1|s7;
+ tearoff s7 = self::Extension1|get#s7;
+ method s8 = self::Extension1|s8;
+ tearoff s8 = self::Extension1|get#s8;
+}
+static method t1() → self::Class<dynamic>
+ ;
+static method t2() → dynamic
+ ;
+static method t3() → self::Class<dynamic>
+ ;
+static method t4() → self::Class<dynamic>
+ ;
+static method t5() → self::ConcreteClass
+ ;
+static method t6() → self::Class<self::ConcreteClass>
+ ;
+static method t7() → core::Object
+ ;
+static method t8() → core::int
+ ;
+static method s1() → self::G<self::Class<dynamic>>
+ ;
+static method s2() → self::G<dynamic>
+ ;
+static method s3() → self::G<self::Class<dynamic>>
+ ;
+static method s4() → self::G<self::Class<dynamic>>
+ ;
+static method s5() → self::G<self::ConcreteClass>
+ ;
+static method s6() → self::G<self::Class<self::ConcreteClass>>
+ ;
+static method s7() → self::G<core::Object>
+ ;
+static method s8() → self::G<core::int>
+ ;
+static method method1() → dynamic
+ ;
+static method Extension1|t1(lowered final core::int #this) → self::Class<dynamic>
+ ;
+static method Extension1|get#t1(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t1(#this);
+static method Extension1|t2(lowered final core::int #this) → dynamic
+ ;
+static method Extension1|get#t2(lowered final core::int #this) → () → dynamic
+ return () → dynamic => self::Extension1|t2(#this);
+static method Extension1|t3(lowered final core::int #this) → self::Class<dynamic>
+ ;
+static method Extension1|get#t3(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t3(#this);
+static method Extension1|t4(lowered final core::int #this) → self::Class<dynamic>
+ ;
+static method Extension1|get#t4(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t4(#this);
+static method Extension1|t5(lowered final core::int #this) → self::ConcreteClass
+ ;
+static method Extension1|get#t5(lowered final core::int #this) → () → self::ConcreteClass
+ return () → self::ConcreteClass => self::Extension1|t5(#this);
+static method Extension1|t6(lowered final core::int #this) → self::Class<self::ConcreteClass>
+ ;
+static method Extension1|get#t6(lowered final core::int #this) → () → self::Class<self::ConcreteClass>
+ return () → self::Class<self::ConcreteClass> => self::Extension1|t6(#this);
+static method Extension1|t7(lowered final core::int #this) → core::Object
+ ;
+static method Extension1|get#t7(lowered final core::int #this) → () → core::Object
+ return () → core::Object => self::Extension1|t7(#this);
+static method Extension1|t8(lowered final core::int #this) → core::int
+ ;
+static method Extension1|get#t8(lowered final core::int #this) → () → core::int
+ return () → core::int => self::Extension1|t8(#this);
+static method Extension1|s1(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ ;
+static method Extension1|get#s1(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s1(#this);
+static method Extension1|s2(lowered final core::int #this) → self::G<dynamic>
+ ;
+static method Extension1|get#s2(lowered final core::int #this) → () → self::G<dynamic>
+ return () → self::G<dynamic> => self::Extension1|s2(#this);
+static method Extension1|s3(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ ;
+static method Extension1|get#s3(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s3(#this);
+static method Extension1|s4(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ ;
+static method Extension1|get#s4(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s4(#this);
+static method Extension1|s5(lowered final core::int #this) → self::G<self::ConcreteClass>
+ ;
+static method Extension1|get#s5(lowered final core::int #this) → () → self::G<self::ConcreteClass>
+ return () → self::G<self::ConcreteClass> => self::Extension1|s5(#this);
+static method Extension1|s6(lowered final core::int #this) → self::G<self::Class<self::ConcreteClass>>
+ ;
+static method Extension1|get#s6(lowered final core::int #this) → () → self::G<self::Class<self::ConcreteClass>>
+ return () → self::G<self::Class<self::ConcreteClass>> => self::Extension1|s6(#this);
+static method Extension1|s7(lowered final core::int #this) → self::G<core::Object>
+ ;
+static method Extension1|get#s7(lowered final core::int #this) → () → self::G<core::Object>
+ return () → self::G<core::Object> => self::Extension1|s7(#this);
+static method Extension1|s8(lowered final core::int #this) → self::G<core::int>
+ ;
+static method Extension1|get#s8(lowered final core::int #this) → () → self::G<core::int>
+ return () → self::G<core::int> => self::Extension1|s8(#this);
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_return_types.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.transformed.expect
new file mode 100644
index 0000000..6adeaf2
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_return_types.dart.weak.transformed.expect
@@ -0,0 +1,377 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:19:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:20:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:27:1: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:28:1: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:56:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:57:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:64:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:65:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:75:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:76:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:83:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:84:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:37:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> t7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:38:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> t8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:45:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> s7() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_return_types.dart:46:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_return_types.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> s8() => throw ''; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_return_types.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+ method t1() → self::Class<dynamic>
+ return throw "";
+ method t2() → dynamic
+ return throw "";
+ method t3() → self::Class<dynamic>
+ return throw "";
+ method t4() → self::Class<dynamic>
+ return throw "";
+ method t5() → self::ConcreteClass
+ return throw "";
+ method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ method t7() → core::Object
+ return throw "";
+ method t8() → core::int
+ return throw "";
+ method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s2() → self::G<dynamic>
+ return throw "";
+ method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ method s5() → self::G<self::ConcreteClass>
+ return throw "";
+ method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ method s7() → self::G<core::Object>
+ return throw "";
+ method s8() → self::G<core::int>
+ return throw "";
+}
+extension Extension1 on core::int {
+ method t1 = self::Extension1|t1;
+ tearoff t1 = self::Extension1|get#t1;
+ method t2 = self::Extension1|t2;
+ tearoff t2 = self::Extension1|get#t2;
+ method t3 = self::Extension1|t3;
+ tearoff t3 = self::Extension1|get#t3;
+ method t4 = self::Extension1|t4;
+ tearoff t4 = self::Extension1|get#t4;
+ method t5 = self::Extension1|t5;
+ tearoff t5 = self::Extension1|get#t5;
+ method t6 = self::Extension1|t6;
+ tearoff t6 = self::Extension1|get#t6;
+ method t7 = self::Extension1|t7;
+ tearoff t7 = self::Extension1|get#t7;
+ method t8 = self::Extension1|t8;
+ tearoff t8 = self::Extension1|get#t8;
+ method s1 = self::Extension1|s1;
+ tearoff s1 = self::Extension1|get#s1;
+ method s2 = self::Extension1|s2;
+ tearoff s2 = self::Extension1|get#s2;
+ method s3 = self::Extension1|s3;
+ tearoff s3 = self::Extension1|get#s3;
+ method s4 = self::Extension1|s4;
+ tearoff s4 = self::Extension1|get#s4;
+ method s5 = self::Extension1|s5;
+ tearoff s5 = self::Extension1|get#s5;
+ method s6 = self::Extension1|s6;
+ tearoff s6 = self::Extension1|get#s6;
+ method s7 = self::Extension1|s7;
+ tearoff s7 = self::Extension1|get#s7;
+ method s8 = self::Extension1|s8;
+ tearoff s8 = self::Extension1|get#s8;
+}
+static method t1() → self::Class<dynamic>
+ return throw "";
+static method t2() → dynamic
+ return throw "";
+static method t3() → self::Class<dynamic>
+ return throw "";
+static method t4() → self::Class<dynamic>
+ return throw "";
+static method t5() → self::ConcreteClass
+ return throw "";
+static method t6() → self::Class<self::ConcreteClass>
+ return throw "";
+static method t7() → core::Object
+ return throw "";
+static method t8() → core::int
+ return throw "";
+static method s1() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s2() → self::G<dynamic>
+ return throw "";
+static method s3() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s4() → self::G<self::Class<dynamic>>
+ return throw "";
+static method s5() → self::G<self::ConcreteClass>
+ return throw "";
+static method s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method s7() → self::G<core::Object>
+ return throw "";
+static method s8() → self::G<core::int>
+ return throw "";
+static method method1() → dynamic {
+ function t1() → self::Class<dynamic>
+ return throw "";
+ function t2() → dynamic
+ return throw "";
+ function t3() → self::Class<dynamic>
+ return throw "";
+ function t4() → self::Class<dynamic>
+ return throw "";
+ function t5() → self::ConcreteClass
+ return throw "";
+ function t6() → self::Class<self::ConcreteClass>
+ return throw "";
+ function t7() → core::Object
+ return throw "";
+ function t8() → core::int
+ return throw "";
+ function s1() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s2() → self::G<dynamic>
+ return throw "";
+ function s3() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s4() → self::G<self::Class<dynamic>>
+ return throw "";
+ function s5() → self::G<self::ConcreteClass>
+ return throw "";
+ function s6() → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+ function s7() → self::G<core::Object>
+ return throw "";
+ function s8() → self::G<core::int>
+ return throw "";
+}
+static method Extension1|t1(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t1(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t1(#this);
+static method Extension1|t2(lowered final core::int #this) → dynamic
+ return throw "";
+static method Extension1|get#t2(lowered final core::int #this) → () → dynamic
+ return () → dynamic => self::Extension1|t2(#this);
+static method Extension1|t3(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t3(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t3(#this);
+static method Extension1|t4(lowered final core::int #this) → self::Class<dynamic>
+ return throw "";
+static method Extension1|get#t4(lowered final core::int #this) → () → self::Class<dynamic>
+ return () → self::Class<dynamic> => self::Extension1|t4(#this);
+static method Extension1|t5(lowered final core::int #this) → self::ConcreteClass
+ return throw "";
+static method Extension1|get#t5(lowered final core::int #this) → () → self::ConcreteClass
+ return () → self::ConcreteClass => self::Extension1|t5(#this);
+static method Extension1|t6(lowered final core::int #this) → self::Class<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#t6(lowered final core::int #this) → () → self::Class<self::ConcreteClass>
+ return () → self::Class<self::ConcreteClass> => self::Extension1|t6(#this);
+static method Extension1|t7(lowered final core::int #this) → core::Object
+ return throw "";
+static method Extension1|get#t7(lowered final core::int #this) → () → core::Object
+ return () → core::Object => self::Extension1|t7(#this);
+static method Extension1|t8(lowered final core::int #this) → core::int
+ return throw "";
+static method Extension1|get#t8(lowered final core::int #this) → () → core::int
+ return () → core::int => self::Extension1|t8(#this);
+static method Extension1|s1(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s1(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s1(#this);
+static method Extension1|s2(lowered final core::int #this) → self::G<dynamic>
+ return throw "";
+static method Extension1|get#s2(lowered final core::int #this) → () → self::G<dynamic>
+ return () → self::G<dynamic> => self::Extension1|s2(#this);
+static method Extension1|s3(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s3(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s3(#this);
+static method Extension1|s4(lowered final core::int #this) → self::G<self::Class<dynamic>>
+ return throw "";
+static method Extension1|get#s4(lowered final core::int #this) → () → self::G<self::Class<dynamic>>
+ return () → self::G<self::Class<dynamic>> => self::Extension1|s4(#this);
+static method Extension1|s5(lowered final core::int #this) → self::G<self::ConcreteClass>
+ return throw "";
+static method Extension1|get#s5(lowered final core::int #this) → () → self::G<self::ConcreteClass>
+ return () → self::G<self::ConcreteClass> => self::Extension1|s5(#this);
+static method Extension1|s6(lowered final core::int #this) → self::G<self::Class<self::ConcreteClass>>
+ return throw "";
+static method Extension1|get#s6(lowered final core::int #this) → () → self::G<self::Class<self::ConcreteClass>>
+ return () → self::G<self::Class<self::ConcreteClass>> => self::Extension1|s6(#this);
+static method Extension1|s7(lowered final core::int #this) → self::G<core::Object>
+ return throw "";
+static method Extension1|get#s7(lowered final core::int #this) → () → self::G<core::Object>
+ return () → self::G<core::Object> => self::Extension1|s7(#this);
+static method Extension1|s8(lowered final core::int #this) → self::G<core::int>
+ return throw "";
+static method Extension1|get#s8(lowered final core::int #this) → () → self::G<core::int>
+ return () → self::G<core::int> => self::Extension1|s8(#this);
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart b/pkg/front_end/testcases/general/bounds_supertypes.dart
new file mode 100644
index 0000000..40f4ea1
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart
@@ -0,0 +1,237 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = Class<X>;
+
+class G<X extends Class<X>> {}
+
+class ExtendsT1 extends F {} // Error
+
+class ExtendsT2 extends F<dynamic> {} // Error
+
+class ExtendsT3 extends F<Class> {} // Error
+
+class ExtendsT4 extends F<Class<dynamic>> {} // Error
+
+class ExtendsT5 extends F<ConcreteClass> {} // Ok
+
+class ExtendsT6 extends F<Class<ConcreteClass>> {} // Ok
+
+class ExtendsT7 extends F<Object> {} // Error
+
+class ExtendsT8 extends F<int> {} // Error
+
+class ExtendsS1 extends G {} // Error
+
+class ExtendsS2 extends G<dynamic> {} // Error
+
+class ExtendsS3 extends G<Class> {} // Error
+
+class ExtendsS4 extends G<Class<dynamic>> {} // Error
+
+class ExtendsS5 extends G<ConcreteClass> {} // Ok
+
+class ExtendsS6 extends G<Class<ConcreteClass>> {} // Ok
+
+class ExtendsS7 extends G<Object> {} // Error
+
+class ExtendsS8 extends G<int> {} // Error
+
+class ImplementsT1 implements F {} // Error
+
+class ImplementsT2 implements F<dynamic> {} // Error
+
+class ImplementsT3 implements F<Class> {} // Error
+
+class ImplementsT4 implements F<Class<dynamic>> {} // Error
+
+class ImplementsT5 implements F<ConcreteClass> {} // Ok
+
+class ImplementsT6 implements F<Class<ConcreteClass>> {} // Ok
+
+class ImplementsT7 implements F<Object> {} // Error
+
+class ImplementsT8 implements F<int> {} // Error
+
+class ImplementsS1 implements G {} // Error
+
+class ImplementsS2 implements G<dynamic> {} // Error
+
+class ImplementsS3 implements G<Class> {} // Error
+
+class ImplementsS4 implements G<Class<dynamic>> {} // Error
+
+class ImplementsS5 implements G<ConcreteClass> {} // Ok
+
+class ImplementsS6 implements G<Class<ConcreteClass>> {} // Ok
+
+class ImplementsS7 implements G<Object> {} // Error
+
+class ImplementsS8 implements G<int> {} // Error
+
+class WithT1 with F {} // Error
+
+class WithT2 with F<dynamic> {} // Error
+
+class WithT3 with F<Class> {} // Error
+
+class WithT4 with F<Class<dynamic>> {} // Error
+
+class WithT5 with F<ConcreteClass> {} // Ok
+
+class WithT6 with F<Class<ConcreteClass>> {} // Ok
+
+class WithT7 with F<Object> {} // Error
+
+class WithT8 with F<int> {} // Error
+
+class WithS1 with G {} // Error
+
+class WithS2 with G<dynamic> {} // Error
+
+class WithS3 with G<Class> {} // Error
+
+class WithS4 with G<Class<dynamic>> {} // Error
+
+class WithS5 with G<ConcreteClass> {} // Ok
+
+class WithS6 with G<Class<ConcreteClass>> {} // Ok
+
+class WithS7 with G<Object> {} // Error
+
+class WithS8 with G<int> {} // Error
+
+enum EnumImplementsT1 implements F /* Error */ { a }
+
+enum EnumImplementsT2 implements F<dynamic> /* Error */ { a }
+
+enum EnumImplementsT3 implements F<Class> /* Error */ { a }
+
+enum EnumImplementsT4 implements F<Class<dynamic>> /* Error */ { a }
+
+enum EnumImplementsT5 implements F<ConcreteClass> /* Ok */ { a }
+
+enum EnumImplementsT6 implements F<Class<ConcreteClass>> /* Ok */ { a }
+
+enum EnumImplementsT7 implements F<Object> /* Error */ { a }
+
+enum EnumImplementsT8 implements F<int> /* Error */ { a }
+
+enum EnumImplementsS1 implements G /* Error */ { a }
+
+enum EnumImplementsS2 implements G<dynamic> /* Error */ { a }
+
+enum EnumImplementsS3 implements G<Class> /* Error */ { a }
+
+enum EnumImplementsS4 implements G<Class<dynamic>> /* Error */ { a }
+
+enum EnumImplementsS5 implements G<ConcreteClass> /* Ok */ { a }
+
+enum EnumImplementsS6 implements G<Class<ConcreteClass>> /* Ok */ { a }
+
+enum EnumImplementsS7 implements G<Object> /* Error */ { a }
+
+enum EnumImplementsS8 implements G<int> /* Error */ { a }
+
+enum EnumWithT1 with F /* Error */ { a }
+
+enum EnumWithT2 with F<dynamic> /* Error */ { a }
+
+enum EnumWithT3 with F<Class> /* Error */ { a }
+
+enum EnumWithT4 with F<Class<dynamic>> /* Error */ { a }
+
+enum EnumWithT5 with F<ConcreteClass> /* Ok */ { a }
+
+enum EnumWithT6 with F<Class<ConcreteClass>> /* Ok */ { a }
+
+enum EnumWithT7 with F<Object> /* Error */ { a }
+
+enum EnumWithT8 with F<int> /* Error */ { a }
+
+enum EnumWithS1 with G /* Error */ { a }
+
+enum EnumWithS2 with G<dynamic> /* Error */ { a }
+
+enum EnumWithS3 with G<Class> /* Error */ { a }
+
+enum EnumWithS4 with G<Class<dynamic>> /* Error */ { a }
+
+enum EnumWithS5 with G<ConcreteClass> /* Ok */ { a }
+
+enum EnumWithS6 with G<Class<ConcreteClass>> /* Ok */ { a }
+
+enum EnumWithS7 with G<Object> /* Error */ { a }
+
+enum EnumWithS8 with G<int> /* Error */ { a }
+
+mixin MixinOnT1 on F {} // Error
+
+mixin MixinOnT2 on F<dynamic> {} // Error
+
+mixin MixinOnT3 on F<Class> {} // Error
+
+mixin MixinOnT4 on F<Class<dynamic>> {} // Error
+
+mixin MixinOnT5 on F<ConcreteClass> {} // Ok
+
+mixin MixinOnT6 on F<Class<ConcreteClass>> {} // Ok
+
+mixin MixinOnT7 on F<Object> {} // Error
+
+mixin MixinOnT8 on F<int> {} // Error
+
+mixin MixinOnS1 on G {} // Error
+
+mixin MixinOnS2 on G<dynamic> {} // Error
+
+mixin MixinOnS3 on G<Class> {} // Error
+
+mixin MixinOnS4 on G<Class<dynamic>> {} // Error
+
+mixin MixinOnS5 on G<ConcreteClass> {} // Ok
+
+mixin MixinOnS6 on G<Class<ConcreteClass>> {} // Ok
+
+mixin MixinOnS7 on G<Object> {} // Error
+
+mixin MixinOnS8 on G<int> {} // Error
+
+extension ExtensionOnT1 on F {} // Ok
+
+extension ExtensionOnT2 on F<dynamic> {} // Ok
+
+extension ExtensionOnT3 on F<Class> {} // Ok
+
+extension ExtensionOnT4 on F<Class<dynamic>> {} // Ok
+
+extension ExtensionOnT5 on F<ConcreteClass> {} // Ok
+
+extension ExtensionOnT6 on F<Class<ConcreteClass>> {} // Ok
+
+extension ExtensionOnT7 on F<Object> {} // Error
+
+extension ExtensionOnT8 on F<int> {} // Error
+
+extension ExtensionOnS1 on G {} // Ok
+
+extension ExtensionOnS2 on G<dynamic> {} // Ok
+
+extension ExtensionOnS3 on G<Class> {} // Ok
+
+extension ExtensionOnS4 on G<Class<dynamic>> {} // Ok
+
+extension ExtensionOnS5 on G<ConcreteClass> {} // Ok
+
+extension ExtensionOnS6 on G<Class<ConcreteClass>> {} // Ok
+
+extension ExtensionOnS7 on G<Object> {} // Error
+
+extension ExtensionOnS8 on G<int> {} // Error
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline.expect
new file mode 100644
index 0000000..411c612
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline.expect
@@ -0,0 +1,218 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = Class<X>;
+
+class G<X extends Class<X>> {}
+
+class ExtendsT1 extends F {}
+
+class ExtendsT2 extends F<dynamic> {}
+
+class ExtendsT3 extends F<Class> {}
+
+class ExtendsT4 extends F<Class<dynamic>> {}
+
+class ExtendsT5 extends F<ConcreteClass> {}
+
+class ExtendsT6 extends F<Class<ConcreteClass>> {}
+
+class ExtendsT7 extends F<Object> {}
+
+class ExtendsT8 extends F<int> {}
+
+class ExtendsS1 extends G {}
+
+class ExtendsS2 extends G<dynamic> {}
+
+class ExtendsS3 extends G<Class> {}
+
+class ExtendsS4 extends G<Class<dynamic>> {}
+
+class ExtendsS5 extends G<ConcreteClass> {}
+
+class ExtendsS6 extends G<Class<ConcreteClass>> {}
+
+class ExtendsS7 extends G<Object> {}
+
+class ExtendsS8 extends G<int> {}
+
+class ImplementsT1 implements F {}
+
+class ImplementsT2 implements F<dynamic> {}
+
+class ImplementsT3 implements F<Class> {}
+
+class ImplementsT4 implements F<Class<dynamic>> {}
+
+class ImplementsT5 implements F<ConcreteClass> {}
+
+class ImplementsT6 implements F<Class<ConcreteClass>> {}
+
+class ImplementsT7 implements F<Object> {}
+
+class ImplementsT8 implements F<int> {}
+
+class ImplementsS1 implements G {}
+
+class ImplementsS2 implements G<dynamic> {}
+
+class ImplementsS3 implements G<Class> {}
+
+class ImplementsS4 implements G<Class<dynamic>> {}
+
+class ImplementsS5 implements G<ConcreteClass> {}
+
+class ImplementsS6 implements G<Class<ConcreteClass>> {}
+
+class ImplementsS7 implements G<Object> {}
+
+class ImplementsS8 implements G<int> {}
+
+class WithT1 with F {}
+
+class WithT2 with F<dynamic> {}
+
+class WithT3 with F<Class> {}
+
+class WithT4 with F<Class<dynamic>> {}
+
+class WithT5 with F<ConcreteClass> {}
+
+class WithT6 with F<Class<ConcreteClass>> {}
+
+class WithT7 with F<Object> {}
+
+class WithT8 with F<int> {}
+
+class WithS1 with G {}
+
+class WithS2 with G<dynamic> {}
+
+class WithS3 with G<Class> {}
+
+class WithS4 with G<Class<dynamic>> {}
+
+class WithS5 with G<ConcreteClass> {}
+
+class WithS6 with G<Class<ConcreteClass>> {}
+
+class WithS7 with G<Object> {}
+
+class WithS8 with G<int> {}
+
+enum EnumImplementsT1 implements F { a }
+
+enum EnumImplementsT2 implements F<dynamic> { a }
+
+enum EnumImplementsT3 implements F<Class> { a }
+
+enum EnumImplementsT4 implements F<Class<dynamic>> { a }
+
+enum EnumImplementsT5 implements F<ConcreteClass> { a }
+
+enum EnumImplementsT6 implements F<Class<ConcreteClass>> { a }
+
+enum EnumImplementsT7 implements F<Object> { a }
+
+enum EnumImplementsT8 implements F<int> { a }
+
+enum EnumImplementsS1 implements G { a }
+
+enum EnumImplementsS2 implements G<dynamic> { a }
+
+enum EnumImplementsS3 implements G<Class> { a }
+
+enum EnumImplementsS4 implements G<Class<dynamic>> { a }
+
+enum EnumImplementsS5 implements G<ConcreteClass> { a }
+
+enum EnumImplementsS6 implements G<Class<ConcreteClass>> { a }
+
+enum EnumImplementsS7 implements G<Object> { a }
+
+enum EnumImplementsS8 implements G<int> { a }
+
+enum EnumWithT1 with F { a }
+
+enum EnumWithT2 with F<dynamic> { a }
+
+enum EnumWithT3 with F<Class> { a }
+
+enum EnumWithT4 with F<Class<dynamic>> { a }
+
+enum EnumWithT5 with F<ConcreteClass> { a }
+
+enum EnumWithT6 with F<Class<ConcreteClass>> { a }
+
+enum EnumWithT7 with F<Object> { a }
+
+enum EnumWithT8 with F<int> { a }
+
+enum EnumWithS1 with G { a }
+
+enum EnumWithS2 with G<dynamic> { a }
+
+enum EnumWithS3 with G<Class> { a }
+
+enum EnumWithS4 with G<Class<dynamic>> { a }
+
+enum EnumWithS5 with G<ConcreteClass> { a }
+
+enum EnumWithS6 with G<Class<ConcreteClass>> { a }
+
+enum EnumWithS7 with G<Object> { a }
+
+enum EnumWithS8 with G<int> { a }
+
+mixin MixinOnT1 on F {}
+mixin MixinOnT2 on F<dynamic> {}
+mixin MixinOnT3 on F<Class> {}
+mixin MixinOnT4 on F<Class<dynamic>> {}
+mixin MixinOnT5 on F<ConcreteClass> {}
+mixin MixinOnT6 on F<Class<ConcreteClass>> {}
+mixin MixinOnT7 on F<Object> {}
+mixin MixinOnT8 on F<int> {}
+mixin MixinOnS1 on G {}
+mixin MixinOnS2 on G<dynamic> {}
+mixin MixinOnS3 on G<Class> {}
+mixin MixinOnS4 on G<Class<dynamic>> {}
+mixin MixinOnS5 on G<ConcreteClass> {}
+mixin MixinOnS6 on G<Class<ConcreteClass>> {}
+mixin MixinOnS7 on G<Object> {}
+mixin MixinOnS8 on G<int> {}
+
+extension ExtensionOnT1 on F {}
+
+extension ExtensionOnT2 on F<dynamic> {}
+
+extension ExtensionOnT3 on F<Class> {}
+
+extension ExtensionOnT4 on F<Class<dynamic>> {}
+
+extension ExtensionOnT5 on F<ConcreteClass> {}
+
+extension ExtensionOnT6 on F<Class<ConcreteClass>> {}
+
+extension ExtensionOnT7 on F<Object> {}
+
+extension ExtensionOnT8 on F<int> {}
+
+extension ExtensionOnS1 on G {}
+
+extension ExtensionOnS2 on G<dynamic> {}
+
+extension ExtensionOnS3 on G<Class> {}
+
+extension ExtensionOnS4 on G<Class<dynamic>> {}
+
+extension ExtensionOnS5 on G<ConcreteClass> {}
+
+extension ExtensionOnS6 on G<Class<ConcreteClass>> {}
+
+extension ExtensionOnS7 on G<Object> {}
+
+extension ExtensionOnS8 on G<int> {}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..5203bb6
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.textual_outline_modelled.expect
@@ -0,0 +1,216 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class ExtendsS1 extends G {}
+
+class ExtendsS2 extends G<dynamic> {}
+
+class ExtendsS3 extends G<Class> {}
+
+class ExtendsS4 extends G<Class<dynamic>> {}
+
+class ExtendsS5 extends G<ConcreteClass> {}
+
+class ExtendsS6 extends G<Class<ConcreteClass>> {}
+
+class ExtendsS7 extends G<Object> {}
+
+class ExtendsS8 extends G<int> {}
+
+class ExtendsT1 extends F {}
+
+class ExtendsT2 extends F<dynamic> {}
+
+class ExtendsT3 extends F<Class> {}
+
+class ExtendsT4 extends F<Class<dynamic>> {}
+
+class ExtendsT5 extends F<ConcreteClass> {}
+
+class ExtendsT6 extends F<Class<ConcreteClass>> {}
+
+class ExtendsT7 extends F<Object> {}
+
+class ExtendsT8 extends F<int> {}
+
+class G<X extends Class<X>> {}
+
+class ImplementsS1 implements G {}
+
+class ImplementsS2 implements G<dynamic> {}
+
+class ImplementsS3 implements G<Class> {}
+
+class ImplementsS4 implements G<Class<dynamic>> {}
+
+class ImplementsS5 implements G<ConcreteClass> {}
+
+class ImplementsS6 implements G<Class<ConcreteClass>> {}
+
+class ImplementsS7 implements G<Object> {}
+
+class ImplementsS8 implements G<int> {}
+
+class ImplementsT1 implements F {}
+
+class ImplementsT2 implements F<dynamic> {}
+
+class ImplementsT3 implements F<Class> {}
+
+class ImplementsT4 implements F<Class<dynamic>> {}
+
+class ImplementsT5 implements F<ConcreteClass> {}
+
+class ImplementsT6 implements F<Class<ConcreteClass>> {}
+
+class ImplementsT7 implements F<Object> {}
+
+class ImplementsT8 implements F<int> {}
+
+class WithS1 with G {}
+
+class WithS2 with G<dynamic> {}
+
+class WithS3 with G<Class> {}
+
+class WithS4 with G<Class<dynamic>> {}
+
+class WithS5 with G<ConcreteClass> {}
+
+class WithS6 with G<Class<ConcreteClass>> {}
+
+class WithS7 with G<Object> {}
+
+class WithS8 with G<int> {}
+
+class WithT1 with F {}
+
+class WithT2 with F<dynamic> {}
+
+class WithT3 with F<Class> {}
+
+class WithT4 with F<Class<dynamic>> {}
+
+class WithT5 with F<ConcreteClass> {}
+
+class WithT6 with F<Class<ConcreteClass>> {}
+
+class WithT7 with F<Object> {}
+
+class WithT8 with F<int> {}
+
+enum EnumImplementsS1 implements G { a }
+
+enum EnumImplementsS2 implements G<dynamic> { a }
+
+enum EnumImplementsS3 implements G<Class> { a }
+
+enum EnumImplementsS4 implements G<Class<dynamic>> { a }
+
+enum EnumImplementsS5 implements G<ConcreteClass> { a }
+
+enum EnumImplementsS6 implements G<Class<ConcreteClass>> { a }
+
+enum EnumImplementsS7 implements G<Object> { a }
+
+enum EnumImplementsS8 implements G<int> { a }
+
+enum EnumImplementsT1 implements F { a }
+
+enum EnumImplementsT2 implements F<dynamic> { a }
+
+enum EnumImplementsT3 implements F<Class> { a }
+
+enum EnumImplementsT4 implements F<Class<dynamic>> { a }
+
+enum EnumImplementsT5 implements F<ConcreteClass> { a }
+
+enum EnumImplementsT6 implements F<Class<ConcreteClass>> { a }
+
+enum EnumImplementsT7 implements F<Object> { a }
+
+enum EnumImplementsT8 implements F<int> { a }
+
+enum EnumWithS1 with G { a }
+
+enum EnumWithS2 with G<dynamic> { a }
+
+enum EnumWithS3 with G<Class> { a }
+
+enum EnumWithS4 with G<Class<dynamic>> { a }
+
+enum EnumWithS5 with G<ConcreteClass> { a }
+
+enum EnumWithS6 with G<Class<ConcreteClass>> { a }
+
+enum EnumWithS7 with G<Object> { a }
+
+enum EnumWithS8 with G<int> { a }
+
+enum EnumWithT1 with F { a }
+
+enum EnumWithT2 with F<dynamic> { a }
+
+enum EnumWithT3 with F<Class> { a }
+
+enum EnumWithT4 with F<Class<dynamic>> { a }
+
+enum EnumWithT5 with F<ConcreteClass> { a }
+
+enum EnumWithT6 with F<Class<ConcreteClass>> { a }
+
+enum EnumWithT7 with F<Object> { a }
+
+enum EnumWithT8 with F<int> { a }
+
+extension ExtensionOnS1 on G {}
+
+extension ExtensionOnS2 on G<dynamic> {}
+
+extension ExtensionOnS3 on G<Class> {}
+
+extension ExtensionOnS4 on G<Class<dynamic>> {}
+
+extension ExtensionOnS5 on G<ConcreteClass> {}
+
+extension ExtensionOnS6 on G<Class<ConcreteClass>> {}
+
+extension ExtensionOnS7 on G<Object> {}
+
+extension ExtensionOnS8 on G<int> {}
+
+extension ExtensionOnT1 on F {}
+
+extension ExtensionOnT2 on F<dynamic> {}
+
+extension ExtensionOnT3 on F<Class> {}
+
+extension ExtensionOnT4 on F<Class<dynamic>> {}
+
+extension ExtensionOnT5 on F<ConcreteClass> {}
+
+extension ExtensionOnT6 on F<Class<ConcreteClass>> {}
+
+extension ExtensionOnT7 on F<Object> {}
+
+extension ExtensionOnT8 on F<int> {}
+
+main() {}
+mixin MixinOnS1 on G {}
+mixin MixinOnS2 on G<dynamic> {}
+mixin MixinOnS3 on G<Class> {}
+mixin MixinOnS4 on G<Class<dynamic>> {}
+mixin MixinOnS5 on G<ConcreteClass> {}
+mixin MixinOnS6 on G<Class<ConcreteClass>> {}
+mixin MixinOnS7 on G<Object> {}
+mixin MixinOnS8 on G<int> {}
+mixin MixinOnT1 on F {}
+mixin MixinOnT2 on F<dynamic> {}
+mixin MixinOnT3 on F<Class> {}
+mixin MixinOnT4 on F<Class<dynamic>> {}
+mixin MixinOnT5 on F<ConcreteClass> {}
+mixin MixinOnT6 on F<Class<ConcreteClass>> {}
+mixin MixinOnT7 on F<Object> {}
+mixin MixinOnT8 on F<int> {}
+typedef F<X extends Class<X>> = Class<X>;
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.expect
new file mode 100644
index 0000000..4b8667d
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.expect
@@ -0,0 +1,1599 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:13:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsT1 extends F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:15:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT2 extends F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:17:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT3 extends F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:19:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT4 extends F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:25:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT7 extends F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:27:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT8 extends F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:29:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsS1 extends G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:31:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS2 extends G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:33:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS3 extends G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:35:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS4 extends G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:41:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS7 extends G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:43:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS8 extends G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:45:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsT1 implements F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:47:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT2 implements F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:49:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT3 implements F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:51:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT4 implements F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:57:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT7 implements F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:59:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT8 implements F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:61:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsS1 implements G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:63:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS2 implements G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:65:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS3 implements G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:67:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS4 implements G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:73:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS7 implements G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:75:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS8 implements G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:77:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithT1 with F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:79:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT2 with F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:81:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT3 with F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:83:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT4 with F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:89:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT7 with F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:91:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT8 with F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:109:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsT1 implements F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:111:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT2 implements F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:113:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT3 implements F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:115:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT4 implements F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:121:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT7 implements F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:123:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT8 implements F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:125:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsS1 implements G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:127:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS2 implements G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:129:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS3 implements G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:131:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS4 implements G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:137:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS7 implements G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:139:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS8 implements G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:141:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithT1 with F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:143:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT2 with F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:145:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT3 with F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:147:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT4 with F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:153:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT7 with F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:155:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT8 with F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:173:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnT1 on F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:175:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT2 on F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:177:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT3 on F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:179:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT4 on F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:185:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:187:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:189:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnS1 on G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:191:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS2 on G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:193:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS3 on G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:195:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS4 on G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:201:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:203:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:217:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:219:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:233:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:235:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:93:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithS1 with G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:95:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS2 with G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:97:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS3 with G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:99:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS4 with G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:105:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS7 with G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:107:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS8 with G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:157:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithS1 with G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:159:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS2 with G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:161:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS3 with G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:163:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS4 with G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:169:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS7 with G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:171:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS8 with G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = self::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class ExtendsT1 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT1
+ : super self::Class::•()
+ ;
+}
+class ExtendsT2 extends self::Class<dynamic> {
+ synthetic constructor •() → self::ExtendsT2
+ : super self::Class::•()
+ ;
+}
+class ExtendsT3 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT3
+ : super self::Class::•()
+ ;
+}
+class ExtendsT4 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT4
+ : super self::Class::•()
+ ;
+}
+class ExtendsT5 extends self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsT5
+ : super self::Class::•()
+ ;
+}
+class ExtendsT6 extends self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsT6
+ : super self::Class::•()
+ ;
+}
+class ExtendsT7 extends self::Class<core::Object> {
+ synthetic constructor •() → self::ExtendsT7
+ : super self::Class::•()
+ ;
+}
+class ExtendsT8 extends self::Class<core::int> {
+ synthetic constructor •() → self::ExtendsT8
+ : super self::Class::•()
+ ;
+}
+class ExtendsS1 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS1
+ : super self::G::•()
+ ;
+}
+class ExtendsS2 extends self::G<dynamic> {
+ synthetic constructor •() → self::ExtendsS2
+ : super self::G::•()
+ ;
+}
+class ExtendsS3 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS3
+ : super self::G::•()
+ ;
+}
+class ExtendsS4 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS4
+ : super self::G::•()
+ ;
+}
+class ExtendsS5 extends self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsS5
+ : super self::G::•()
+ ;
+}
+class ExtendsS6 extends self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsS6
+ : super self::G::•()
+ ;
+}
+class ExtendsS7 extends self::G<core::Object> {
+ synthetic constructor •() → self::ExtendsS7
+ : super self::G::•()
+ ;
+}
+class ExtendsS8 extends self::G<core::int> {
+ synthetic constructor •() → self::ExtendsS8
+ : super self::G::•()
+ ;
+}
+class ImplementsT1 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT1
+ : super core::Object::•()
+ ;
+}
+class ImplementsT2 extends core::Object implements self::Class<dynamic> {
+ synthetic constructor •() → self::ImplementsT2
+ : super core::Object::•()
+ ;
+}
+class ImplementsT3 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT3
+ : super core::Object::•()
+ ;
+}
+class ImplementsT4 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT4
+ : super core::Object::•()
+ ;
+}
+class ImplementsT5 extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsT5
+ : super core::Object::•()
+ ;
+}
+class ImplementsT6 extends core::Object implements self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsT6
+ : super core::Object::•()
+ ;
+}
+class ImplementsT7 extends core::Object implements self::Class<core::Object> {
+ synthetic constructor •() → self::ImplementsT7
+ : super core::Object::•()
+ ;
+}
+class ImplementsT8 extends core::Object implements self::Class<core::int> {
+ synthetic constructor •() → self::ImplementsT8
+ : super core::Object::•()
+ ;
+}
+class ImplementsS1 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS1
+ : super core::Object::•()
+ ;
+}
+class ImplementsS2 extends core::Object implements self::G<dynamic> {
+ synthetic constructor •() → self::ImplementsS2
+ : super core::Object::•()
+ ;
+}
+class ImplementsS3 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS3
+ : super core::Object::•()
+ ;
+}
+class ImplementsS4 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS4
+ : super core::Object::•()
+ ;
+}
+class ImplementsS5 extends core::Object implements self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsS5
+ : super core::Object::•()
+ ;
+}
+class ImplementsS6 extends core::Object implements self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsS6
+ : super core::Object::•()
+ ;
+}
+class ImplementsS7 extends core::Object implements self::G<core::Object> {
+ synthetic constructor •() → self::ImplementsS7
+ : super core::Object::•()
+ ;
+}
+class ImplementsS8 extends core::Object implements self::G<core::int> {
+ synthetic constructor •() → self::ImplementsS8
+ : super core::Object::•()
+ ;
+}
+abstract class _WithT1&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT1&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT1 extends self::_WithT1&Object&F {
+ synthetic constructor •() → self::WithT1
+ : super self::_WithT1&Object&F::•()
+ ;
+}
+abstract class _WithT2&Object&F = core::Object with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT2&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT2 extends self::_WithT2&Object&F {
+ synthetic constructor •() → self::WithT2
+ : super self::_WithT2&Object&F::•()
+ ;
+}
+abstract class _WithT3&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT3&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT3 extends self::_WithT3&Object&F {
+ synthetic constructor •() → self::WithT3
+ : super self::_WithT3&Object&F::•()
+ ;
+}
+abstract class _WithT4&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT4&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT4 extends self::_WithT4&Object&F {
+ synthetic constructor •() → self::WithT4
+ : super self::_WithT4&Object&F::•()
+ ;
+}
+abstract class _WithT5&Object&F = core::Object with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT5&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT5 extends self::_WithT5&Object&F {
+ synthetic constructor •() → self::WithT5
+ : super self::_WithT5&Object&F::•()
+ ;
+}
+abstract class _WithT6&Object&F = core::Object with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT6&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT6 extends self::_WithT6&Object&F {
+ synthetic constructor •() → self::WithT6
+ : super self::_WithT6&Object&F::•()
+ ;
+}
+abstract class _WithT7&Object&F = core::Object with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT7&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT7 extends self::_WithT7&Object&F {
+ synthetic constructor •() → self::WithT7
+ : super self::_WithT7&Object&F::•()
+ ;
+}
+abstract class _WithT8&Object&F = core::Object with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT8&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT8 extends self::_WithT8&Object&F {
+ synthetic constructor •() → self::WithT8
+ : super self::_WithT8&Object&F::•()
+ ;
+}
+abstract class _WithS1&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS1&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS1 extends self::_WithS1&Object&G {
+ synthetic constructor •() → self::WithS1
+ : super self::_WithS1&Object&G::•()
+ ;
+}
+abstract class _WithS2&Object&G = core::Object with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS2&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS2 extends self::_WithS2&Object&G {
+ synthetic constructor •() → self::WithS2
+ : super self::_WithS2&Object&G::•()
+ ;
+}
+abstract class _WithS3&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS3&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS3 extends self::_WithS3&Object&G {
+ synthetic constructor •() → self::WithS3
+ : super self::_WithS3&Object&G::•()
+ ;
+}
+abstract class _WithS4&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS4&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS4 extends self::_WithS4&Object&G {
+ synthetic constructor •() → self::WithS4
+ : super self::_WithS4&Object&G::•()
+ ;
+}
+abstract class _WithS5&Object&G = core::Object with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS5&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS5 extends self::_WithS5&Object&G {
+ synthetic constructor •() → self::WithS5
+ : super self::_WithS5&Object&G::•()
+ ;
+}
+abstract class _WithS6&Object&G = core::Object with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS6&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS6 extends self::_WithS6&Object&G {
+ synthetic constructor •() → self::WithS6
+ : super self::_WithS6&Object&G::•()
+ ;
+}
+abstract class _WithS7&Object&G = core::Object with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS7&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS7 extends self::_WithS7&Object&G {
+ synthetic constructor •() → self::WithS7
+ : super self::_WithS7&Object&G::•()
+ ;
+}
+abstract class _WithS8&Object&G = core::Object with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS8&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS8 extends self::_WithS8&Object&G {
+ synthetic constructor •() → self::WithS8
+ : super self::_WithS8&Object&G::•()
+ ;
+}
+class EnumImplementsT1 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT1> values = #C4;
+ static const field self::EnumImplementsT1 a = #C3;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT2 extends core::_Enum implements self::Class<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT2> values = #C6;
+ static const field self::EnumImplementsT2 a = #C5;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT3 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT3> values = #C8;
+ static const field self::EnumImplementsT3 a = #C7;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT4 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT4> values = #C10;
+ static const field self::EnumImplementsT4 a = #C9;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT5 extends core::_Enum implements self::Class<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT5> values = #C12;
+ static const field self::EnumImplementsT5 a = #C11;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT6 extends core::_Enum implements self::Class<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT6> values = #C14;
+ static const field self::EnumImplementsT6 a = #C13;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT7 extends core::_Enum implements self::Class<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT7> values = #C16;
+ static const field self::EnumImplementsT7 a = #C15;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT8 extends core::_Enum implements self::Class<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT8> values = #C18;
+ static const field self::EnumImplementsT8 a = #C17;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT8.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS1 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS1> values = #C20;
+ static const field self::EnumImplementsS1 a = #C19;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS2 extends core::_Enum implements self::G<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS2> values = #C22;
+ static const field self::EnumImplementsS2 a = #C21;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS3 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS3> values = #C24;
+ static const field self::EnumImplementsS3 a = #C23;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS4 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS4> values = #C26;
+ static const field self::EnumImplementsS4 a = #C25;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS5 extends core::_Enum implements self::G<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS5> values = #C28;
+ static const field self::EnumImplementsS5 a = #C27;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS6 extends core::_Enum implements self::G<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS6> values = #C30;
+ static const field self::EnumImplementsS6 a = #C29;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS7 extends core::_Enum implements self::G<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS7> values = #C32;
+ static const field self::EnumImplementsS7 a = #C31;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS8 extends core::_Enum implements self::G<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS8> values = #C34;
+ static const field self::EnumImplementsS8 a = #C33;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT1&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT1&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT1 extends self::_EnumWithT1&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT1> values = #C36;
+ static const field self::EnumWithT1 a = #C35;
+ const constructor •(core::int index, core::String name) → self::EnumWithT1
+ : super self::_EnumWithT1&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT2&_Enum&F = core::_Enum with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT2&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT2 extends self::_EnumWithT2&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT2> values = #C38;
+ static const field self::EnumWithT2 a = #C37;
+ const constructor •(core::int index, core::String name) → self::EnumWithT2
+ : super self::_EnumWithT2&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT3&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT3&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT3 extends self::_EnumWithT3&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT3> values = #C40;
+ static const field self::EnumWithT3 a = #C39;
+ const constructor •(core::int index, core::String name) → self::EnumWithT3
+ : super self::_EnumWithT3&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT4&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT4&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT4 extends self::_EnumWithT4&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT4> values = #C42;
+ static const field self::EnumWithT4 a = #C41;
+ const constructor •(core::int index, core::String name) → self::EnumWithT4
+ : super self::_EnumWithT4&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT5&_Enum&F = core::_Enum with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT5&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT5 extends self::_EnumWithT5&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT5> values = #C44;
+ static const field self::EnumWithT5 a = #C43;
+ const constructor •(core::int index, core::String name) → self::EnumWithT5
+ : super self::_EnumWithT5&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT6&_Enum&F = core::_Enum with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT6&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT6 extends self::_EnumWithT6&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT6> values = #C46;
+ static const field self::EnumWithT6 a = #C45;
+ const constructor •(core::int index, core::String name) → self::EnumWithT6
+ : super self::_EnumWithT6&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT7&_Enum&F = core::_Enum with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT7&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT7 extends self::_EnumWithT7&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT7> values = #C48;
+ static const field self::EnumWithT7 a = #C47;
+ const constructor •(core::int index, core::String name) → self::EnumWithT7
+ : super self::_EnumWithT7&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT8&_Enum&F = core::_Enum with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT8&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT8 extends self::_EnumWithT8&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT8> values = #C50;
+ static const field self::EnumWithT8 a = #C49;
+ const constructor •(core::int index, core::String name) → self::EnumWithT8
+ : super self::_EnumWithT8&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS1&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS1&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS1 extends self::_EnumWithS1&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS1> values = #C52;
+ static const field self::EnumWithS1 a = #C51;
+ const constructor •(core::int index, core::String name) → self::EnumWithS1
+ : super self::_EnumWithS1&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS2&_Enum&G = core::_Enum with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS2&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS2 extends self::_EnumWithS2&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS2> values = #C54;
+ static const field self::EnumWithS2 a = #C53;
+ const constructor •(core::int index, core::String name) → self::EnumWithS2
+ : super self::_EnumWithS2&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS3&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS3&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS3 extends self::_EnumWithS3&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS3> values = #C56;
+ static const field self::EnumWithS3 a = #C55;
+ const constructor •(core::int index, core::String name) → self::EnumWithS3
+ : super self::_EnumWithS3&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS4&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS4&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS4 extends self::_EnumWithS4&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS4> values = #C58;
+ static const field self::EnumWithS4 a = #C57;
+ const constructor •(core::int index, core::String name) → self::EnumWithS4
+ : super self::_EnumWithS4&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS5&_Enum&G = core::_Enum with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS5&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS5 extends self::_EnumWithS5&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS5> values = #C60;
+ static const field self::EnumWithS5 a = #C59;
+ const constructor •(core::int index, core::String name) → self::EnumWithS5
+ : super self::_EnumWithS5&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS6&_Enum&G = core::_Enum with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS6&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS6 extends self::_EnumWithS6&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS6> values = #C62;
+ static const field self::EnumWithS6 a = #C61;
+ const constructor •(core::int index, core::String name) → self::EnumWithS6
+ : super self::_EnumWithS6&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS7&_Enum&G = core::_Enum with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS7&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS7 extends self::_EnumWithS7&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS7> values = #C64;
+ static const field self::EnumWithS7 a = #C63;
+ const constructor •(core::int index, core::String name) → self::EnumWithS7
+ : super self::_EnumWithS7&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS8&_Enum&G = core::_Enum with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS8&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS8 extends self::_EnumWithS8&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS8> values = #C66;
+ static const field self::EnumWithS8 a = #C65;
+ const constructor •(core::int index, core::String name) → self::EnumWithS8
+ : super self::_EnumWithS8&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnT1 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT2 extends self::Class<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT3 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT4 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT5 extends self::Class<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT6 extends self::Class<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT7 extends self::Class<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT8 extends self::Class<core::int> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS1 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS2 extends self::G<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS3 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS4 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS5 extends self::G<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS6 extends self::G<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS7 extends self::G<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS8 extends self::G<core::int> /*isMixinDeclaration*/ {
+}
+extension ExtensionOnT1 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT2 on self::Class<dynamic> {
+}
+extension ExtensionOnT3 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT4 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT5 on self::Class<self::ConcreteClass> {
+}
+extension ExtensionOnT6 on self::Class<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnT7 on self::Class<core::Object> {
+}
+extension ExtensionOnT8 on self::Class<core::int> {
+}
+extension ExtensionOnS1 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS2 on self::G<dynamic> {
+}
+extension ExtensionOnS3 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS4 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS5 on self::G<self::ConcreteClass> {
+}
+extension ExtensionOnS6 on self::G<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnS7 on self::G<core::Object> {
+}
+extension ExtensionOnS8 on self::G<core::int> {
+}
+static method main() → dynamic {}
+static method _#F#new#tearOff<X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class<self::_#F#new#tearOff::X>
+ return new self::Class::•<self::_#F#new#tearOff::X>();
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::EnumImplementsT1 {index:#C1, _name:#C2}
+ #C4 = <self::EnumImplementsT1*>[#C3]
+ #C5 = self::EnumImplementsT2 {index:#C1, _name:#C2}
+ #C6 = <self::EnumImplementsT2*>[#C5]
+ #C7 = self::EnumImplementsT3 {index:#C1, _name:#C2}
+ #C8 = <self::EnumImplementsT3*>[#C7]
+ #C9 = self::EnumImplementsT4 {index:#C1, _name:#C2}
+ #C10 = <self::EnumImplementsT4*>[#C9]
+ #C11 = self::EnumImplementsT5 {index:#C1, _name:#C2}
+ #C12 = <self::EnumImplementsT5*>[#C11]
+ #C13 = self::EnumImplementsT6 {index:#C1, _name:#C2}
+ #C14 = <self::EnumImplementsT6*>[#C13]
+ #C15 = self::EnumImplementsT7 {index:#C1, _name:#C2}
+ #C16 = <self::EnumImplementsT7*>[#C15]
+ #C17 = self::EnumImplementsT8 {index:#C1, _name:#C2}
+ #C18 = <self::EnumImplementsT8*>[#C17]
+ #C19 = self::EnumImplementsS1 {index:#C1, _name:#C2}
+ #C20 = <self::EnumImplementsS1*>[#C19]
+ #C21 = self::EnumImplementsS2 {index:#C1, _name:#C2}
+ #C22 = <self::EnumImplementsS2*>[#C21]
+ #C23 = self::EnumImplementsS3 {index:#C1, _name:#C2}
+ #C24 = <self::EnumImplementsS3*>[#C23]
+ #C25 = self::EnumImplementsS4 {index:#C1, _name:#C2}
+ #C26 = <self::EnumImplementsS4*>[#C25]
+ #C27 = self::EnumImplementsS5 {index:#C1, _name:#C2}
+ #C28 = <self::EnumImplementsS5*>[#C27]
+ #C29 = self::EnumImplementsS6 {index:#C1, _name:#C2}
+ #C30 = <self::EnumImplementsS6*>[#C29]
+ #C31 = self::EnumImplementsS7 {index:#C1, _name:#C2}
+ #C32 = <self::EnumImplementsS7*>[#C31]
+ #C33 = self::EnumImplementsS8 {index:#C1, _name:#C2}
+ #C34 = <self::EnumImplementsS8*>[#C33]
+ #C35 = self::EnumWithT1 {index:#C1, _name:#C2}
+ #C36 = <self::EnumWithT1*>[#C35]
+ #C37 = self::EnumWithT2 {index:#C1, _name:#C2}
+ #C38 = <self::EnumWithT2*>[#C37]
+ #C39 = self::EnumWithT3 {index:#C1, _name:#C2}
+ #C40 = <self::EnumWithT3*>[#C39]
+ #C41 = self::EnumWithT4 {index:#C1, _name:#C2}
+ #C42 = <self::EnumWithT4*>[#C41]
+ #C43 = self::EnumWithT5 {index:#C1, _name:#C2}
+ #C44 = <self::EnumWithT5*>[#C43]
+ #C45 = self::EnumWithT6 {index:#C1, _name:#C2}
+ #C46 = <self::EnumWithT6*>[#C45]
+ #C47 = self::EnumWithT7 {index:#C1, _name:#C2}
+ #C48 = <self::EnumWithT7*>[#C47]
+ #C49 = self::EnumWithT8 {index:#C1, _name:#C2}
+ #C50 = <self::EnumWithT8*>[#C49]
+ #C51 = self::EnumWithS1 {index:#C1, _name:#C2}
+ #C52 = <self::EnumWithS1*>[#C51]
+ #C53 = self::EnumWithS2 {index:#C1, _name:#C2}
+ #C54 = <self::EnumWithS2*>[#C53]
+ #C55 = self::EnumWithS3 {index:#C1, _name:#C2}
+ #C56 = <self::EnumWithS3*>[#C55]
+ #C57 = self::EnumWithS4 {index:#C1, _name:#C2}
+ #C58 = <self::EnumWithS4*>[#C57]
+ #C59 = self::EnumWithS5 {index:#C1, _name:#C2}
+ #C60 = <self::EnumWithS5*>[#C59]
+ #C61 = self::EnumWithS6 {index:#C1, _name:#C2}
+ #C62 = <self::EnumWithS6*>[#C61]
+ #C63 = self::EnumWithS7 {index:#C1, _name:#C2}
+ #C64 = <self::EnumWithS7*>[#C63]
+ #C65 = self::EnumWithS8 {index:#C1, _name:#C2}
+ #C66 = <self::EnumWithS8*>[#C65]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_supertypes.dart:
+- EnumImplementsT1. (from org-dartlang-testcase:///bounds_supertypes.dart:109:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- EnumImplementsT2. (from org-dartlang-testcase:///bounds_supertypes.dart:111:6)
+- EnumImplementsT3. (from org-dartlang-testcase:///bounds_supertypes.dart:113:6)
+- EnumImplementsT4. (from org-dartlang-testcase:///bounds_supertypes.dart:115:6)
+- EnumImplementsT5. (from org-dartlang-testcase:///bounds_supertypes.dart:117:6)
+- EnumImplementsT6. (from org-dartlang-testcase:///bounds_supertypes.dart:119:6)
+- EnumImplementsT7. (from org-dartlang-testcase:///bounds_supertypes.dart:121:6)
+- EnumImplementsT8. (from org-dartlang-testcase:///bounds_supertypes.dart:123:6)
+- EnumImplementsS1. (from org-dartlang-testcase:///bounds_supertypes.dart:125:6)
+- EnumImplementsS2. (from org-dartlang-testcase:///bounds_supertypes.dart:127:6)
+- EnumImplementsS3. (from org-dartlang-testcase:///bounds_supertypes.dart:129:6)
+- EnumImplementsS4. (from org-dartlang-testcase:///bounds_supertypes.dart:131:6)
+- EnumImplementsS5. (from org-dartlang-testcase:///bounds_supertypes.dart:133:6)
+- EnumImplementsS6. (from org-dartlang-testcase:///bounds_supertypes.dart:135:6)
+- EnumImplementsS7. (from org-dartlang-testcase:///bounds_supertypes.dart:137:6)
+- EnumImplementsS8. (from org-dartlang-testcase:///bounds_supertypes.dart:139:6)
+- EnumWithT1. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- _EnumWithT1&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- EnumWithT2. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- _EnumWithT2&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- EnumWithT3. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- _EnumWithT3&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- EnumWithT4. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- _EnumWithT4&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- EnumWithT5. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- _EnumWithT5&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- EnumWithT6. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- _EnumWithT6&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- EnumWithT7. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- _EnumWithT7&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- EnumWithT8. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- _EnumWithT8&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- EnumWithS1. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- _EnumWithS1&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- EnumWithS2. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- _EnumWithS2&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- EnumWithS3. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- _EnumWithS3&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- EnumWithS4. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- _EnumWithS4&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- EnumWithS5. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- _EnumWithS5&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- EnumWithS6. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- _EnumWithS6&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- EnumWithS7. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- _EnumWithS7&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- EnumWithS8. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
+- _EnumWithS8&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.modular.expect
new file mode 100644
index 0000000..4b8667d
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.modular.expect
@@ -0,0 +1,1599 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:13:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsT1 extends F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:15:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT2 extends F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:17:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT3 extends F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:19:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT4 extends F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:25:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT7 extends F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:27:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT8 extends F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:29:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsS1 extends G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:31:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS2 extends G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:33:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS3 extends G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:35:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS4 extends G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:41:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS7 extends G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:43:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS8 extends G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:45:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsT1 implements F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:47:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT2 implements F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:49:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT3 implements F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:51:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT4 implements F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:57:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT7 implements F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:59:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT8 implements F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:61:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsS1 implements G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:63:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS2 implements G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:65:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS3 implements G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:67:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS4 implements G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:73:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS7 implements G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:75:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS8 implements G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:77:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithT1 with F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:79:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT2 with F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:81:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT3 with F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:83:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT4 with F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:89:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT7 with F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:91:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT8 with F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:109:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsT1 implements F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:111:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT2 implements F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:113:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT3 implements F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:115:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT4 implements F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:121:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT7 implements F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:123:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT8 implements F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:125:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsS1 implements G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:127:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS2 implements G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:129:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS3 implements G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:131:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS4 implements G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:137:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS7 implements G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:139:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS8 implements G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:141:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithT1 with F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:143:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT2 with F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:145:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT3 with F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:147:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT4 with F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:153:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT7 with F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:155:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT8 with F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:173:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnT1 on F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:175:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT2 on F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:177:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT3 on F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:179:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT4 on F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:185:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:187:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:189:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnS1 on G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:191:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS2 on G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:193:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS3 on G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:195:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS4 on G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:201:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:203:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:217:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:219:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:233:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:235:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:93:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithS1 with G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:95:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS2 with G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:97:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS3 with G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:99:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS4 with G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:105:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS7 with G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:107:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS8 with G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:157:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithS1 with G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:159:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS2 with G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:161:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS3 with G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:163:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS4 with G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:169:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS7 with G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:171:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS8 with G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = self::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class ExtendsT1 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT1
+ : super self::Class::•()
+ ;
+}
+class ExtendsT2 extends self::Class<dynamic> {
+ synthetic constructor •() → self::ExtendsT2
+ : super self::Class::•()
+ ;
+}
+class ExtendsT3 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT3
+ : super self::Class::•()
+ ;
+}
+class ExtendsT4 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT4
+ : super self::Class::•()
+ ;
+}
+class ExtendsT5 extends self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsT5
+ : super self::Class::•()
+ ;
+}
+class ExtendsT6 extends self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsT6
+ : super self::Class::•()
+ ;
+}
+class ExtendsT7 extends self::Class<core::Object> {
+ synthetic constructor •() → self::ExtendsT7
+ : super self::Class::•()
+ ;
+}
+class ExtendsT8 extends self::Class<core::int> {
+ synthetic constructor •() → self::ExtendsT8
+ : super self::Class::•()
+ ;
+}
+class ExtendsS1 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS1
+ : super self::G::•()
+ ;
+}
+class ExtendsS2 extends self::G<dynamic> {
+ synthetic constructor •() → self::ExtendsS2
+ : super self::G::•()
+ ;
+}
+class ExtendsS3 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS3
+ : super self::G::•()
+ ;
+}
+class ExtendsS4 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS4
+ : super self::G::•()
+ ;
+}
+class ExtendsS5 extends self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsS5
+ : super self::G::•()
+ ;
+}
+class ExtendsS6 extends self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsS6
+ : super self::G::•()
+ ;
+}
+class ExtendsS7 extends self::G<core::Object> {
+ synthetic constructor •() → self::ExtendsS7
+ : super self::G::•()
+ ;
+}
+class ExtendsS8 extends self::G<core::int> {
+ synthetic constructor •() → self::ExtendsS8
+ : super self::G::•()
+ ;
+}
+class ImplementsT1 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT1
+ : super core::Object::•()
+ ;
+}
+class ImplementsT2 extends core::Object implements self::Class<dynamic> {
+ synthetic constructor •() → self::ImplementsT2
+ : super core::Object::•()
+ ;
+}
+class ImplementsT3 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT3
+ : super core::Object::•()
+ ;
+}
+class ImplementsT4 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT4
+ : super core::Object::•()
+ ;
+}
+class ImplementsT5 extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsT5
+ : super core::Object::•()
+ ;
+}
+class ImplementsT6 extends core::Object implements self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsT6
+ : super core::Object::•()
+ ;
+}
+class ImplementsT7 extends core::Object implements self::Class<core::Object> {
+ synthetic constructor •() → self::ImplementsT7
+ : super core::Object::•()
+ ;
+}
+class ImplementsT8 extends core::Object implements self::Class<core::int> {
+ synthetic constructor •() → self::ImplementsT8
+ : super core::Object::•()
+ ;
+}
+class ImplementsS1 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS1
+ : super core::Object::•()
+ ;
+}
+class ImplementsS2 extends core::Object implements self::G<dynamic> {
+ synthetic constructor •() → self::ImplementsS2
+ : super core::Object::•()
+ ;
+}
+class ImplementsS3 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS3
+ : super core::Object::•()
+ ;
+}
+class ImplementsS4 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS4
+ : super core::Object::•()
+ ;
+}
+class ImplementsS5 extends core::Object implements self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsS5
+ : super core::Object::•()
+ ;
+}
+class ImplementsS6 extends core::Object implements self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsS6
+ : super core::Object::•()
+ ;
+}
+class ImplementsS7 extends core::Object implements self::G<core::Object> {
+ synthetic constructor •() → self::ImplementsS7
+ : super core::Object::•()
+ ;
+}
+class ImplementsS8 extends core::Object implements self::G<core::int> {
+ synthetic constructor •() → self::ImplementsS8
+ : super core::Object::•()
+ ;
+}
+abstract class _WithT1&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT1&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT1 extends self::_WithT1&Object&F {
+ synthetic constructor •() → self::WithT1
+ : super self::_WithT1&Object&F::•()
+ ;
+}
+abstract class _WithT2&Object&F = core::Object with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT2&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT2 extends self::_WithT2&Object&F {
+ synthetic constructor •() → self::WithT2
+ : super self::_WithT2&Object&F::•()
+ ;
+}
+abstract class _WithT3&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT3&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT3 extends self::_WithT3&Object&F {
+ synthetic constructor •() → self::WithT3
+ : super self::_WithT3&Object&F::•()
+ ;
+}
+abstract class _WithT4&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT4&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT4 extends self::_WithT4&Object&F {
+ synthetic constructor •() → self::WithT4
+ : super self::_WithT4&Object&F::•()
+ ;
+}
+abstract class _WithT5&Object&F = core::Object with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT5&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT5 extends self::_WithT5&Object&F {
+ synthetic constructor •() → self::WithT5
+ : super self::_WithT5&Object&F::•()
+ ;
+}
+abstract class _WithT6&Object&F = core::Object with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT6&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT6 extends self::_WithT6&Object&F {
+ synthetic constructor •() → self::WithT6
+ : super self::_WithT6&Object&F::•()
+ ;
+}
+abstract class _WithT7&Object&F = core::Object with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT7&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT7 extends self::_WithT7&Object&F {
+ synthetic constructor •() → self::WithT7
+ : super self::_WithT7&Object&F::•()
+ ;
+}
+abstract class _WithT8&Object&F = core::Object with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT8&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT8 extends self::_WithT8&Object&F {
+ synthetic constructor •() → self::WithT8
+ : super self::_WithT8&Object&F::•()
+ ;
+}
+abstract class _WithS1&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS1&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS1 extends self::_WithS1&Object&G {
+ synthetic constructor •() → self::WithS1
+ : super self::_WithS1&Object&G::•()
+ ;
+}
+abstract class _WithS2&Object&G = core::Object with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS2&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS2 extends self::_WithS2&Object&G {
+ synthetic constructor •() → self::WithS2
+ : super self::_WithS2&Object&G::•()
+ ;
+}
+abstract class _WithS3&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS3&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS3 extends self::_WithS3&Object&G {
+ synthetic constructor •() → self::WithS3
+ : super self::_WithS3&Object&G::•()
+ ;
+}
+abstract class _WithS4&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS4&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS4 extends self::_WithS4&Object&G {
+ synthetic constructor •() → self::WithS4
+ : super self::_WithS4&Object&G::•()
+ ;
+}
+abstract class _WithS5&Object&G = core::Object with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS5&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS5 extends self::_WithS5&Object&G {
+ synthetic constructor •() → self::WithS5
+ : super self::_WithS5&Object&G::•()
+ ;
+}
+abstract class _WithS6&Object&G = core::Object with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS6&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS6 extends self::_WithS6&Object&G {
+ synthetic constructor •() → self::WithS6
+ : super self::_WithS6&Object&G::•()
+ ;
+}
+abstract class _WithS7&Object&G = core::Object with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS7&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS7 extends self::_WithS7&Object&G {
+ synthetic constructor •() → self::WithS7
+ : super self::_WithS7&Object&G::•()
+ ;
+}
+abstract class _WithS8&Object&G = core::Object with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS8&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS8 extends self::_WithS8&Object&G {
+ synthetic constructor •() → self::WithS8
+ : super self::_WithS8&Object&G::•()
+ ;
+}
+class EnumImplementsT1 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT1> values = #C4;
+ static const field self::EnumImplementsT1 a = #C3;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT2 extends core::_Enum implements self::Class<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT2> values = #C6;
+ static const field self::EnumImplementsT2 a = #C5;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT3 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT3> values = #C8;
+ static const field self::EnumImplementsT3 a = #C7;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT4 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT4> values = #C10;
+ static const field self::EnumImplementsT4 a = #C9;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT5 extends core::_Enum implements self::Class<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT5> values = #C12;
+ static const field self::EnumImplementsT5 a = #C11;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT6 extends core::_Enum implements self::Class<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT6> values = #C14;
+ static const field self::EnumImplementsT6 a = #C13;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT7 extends core::_Enum implements self::Class<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT7> values = #C16;
+ static const field self::EnumImplementsT7 a = #C15;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT8 extends core::_Enum implements self::Class<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT8> values = #C18;
+ static const field self::EnumImplementsT8 a = #C17;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT8.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS1 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS1> values = #C20;
+ static const field self::EnumImplementsS1 a = #C19;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS2 extends core::_Enum implements self::G<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS2> values = #C22;
+ static const field self::EnumImplementsS2 a = #C21;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS3 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS3> values = #C24;
+ static const field self::EnumImplementsS3 a = #C23;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS4 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS4> values = #C26;
+ static const field self::EnumImplementsS4 a = #C25;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS5 extends core::_Enum implements self::G<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS5> values = #C28;
+ static const field self::EnumImplementsS5 a = #C27;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS6 extends core::_Enum implements self::G<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS6> values = #C30;
+ static const field self::EnumImplementsS6 a = #C29;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS7 extends core::_Enum implements self::G<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS7> values = #C32;
+ static const field self::EnumImplementsS7 a = #C31;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS8 extends core::_Enum implements self::G<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS8> values = #C34;
+ static const field self::EnumImplementsS8 a = #C33;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT1&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT1&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT1 extends self::_EnumWithT1&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT1> values = #C36;
+ static const field self::EnumWithT1 a = #C35;
+ const constructor •(core::int index, core::String name) → self::EnumWithT1
+ : super self::_EnumWithT1&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT2&_Enum&F = core::_Enum with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT2&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT2 extends self::_EnumWithT2&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT2> values = #C38;
+ static const field self::EnumWithT2 a = #C37;
+ const constructor •(core::int index, core::String name) → self::EnumWithT2
+ : super self::_EnumWithT2&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT3&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT3&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT3 extends self::_EnumWithT3&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT3> values = #C40;
+ static const field self::EnumWithT3 a = #C39;
+ const constructor •(core::int index, core::String name) → self::EnumWithT3
+ : super self::_EnumWithT3&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT4&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT4&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT4 extends self::_EnumWithT4&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT4> values = #C42;
+ static const field self::EnumWithT4 a = #C41;
+ const constructor •(core::int index, core::String name) → self::EnumWithT4
+ : super self::_EnumWithT4&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT5&_Enum&F = core::_Enum with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT5&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT5 extends self::_EnumWithT5&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT5> values = #C44;
+ static const field self::EnumWithT5 a = #C43;
+ const constructor •(core::int index, core::String name) → self::EnumWithT5
+ : super self::_EnumWithT5&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT6&_Enum&F = core::_Enum with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT6&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT6 extends self::_EnumWithT6&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT6> values = #C46;
+ static const field self::EnumWithT6 a = #C45;
+ const constructor •(core::int index, core::String name) → self::EnumWithT6
+ : super self::_EnumWithT6&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT7&_Enum&F = core::_Enum with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT7&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT7 extends self::_EnumWithT7&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT7> values = #C48;
+ static const field self::EnumWithT7 a = #C47;
+ const constructor •(core::int index, core::String name) → self::EnumWithT7
+ : super self::_EnumWithT7&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT8&_Enum&F = core::_Enum with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT8&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT8 extends self::_EnumWithT8&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT8> values = #C50;
+ static const field self::EnumWithT8 a = #C49;
+ const constructor •(core::int index, core::String name) → self::EnumWithT8
+ : super self::_EnumWithT8&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS1&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS1&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS1 extends self::_EnumWithS1&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS1> values = #C52;
+ static const field self::EnumWithS1 a = #C51;
+ const constructor •(core::int index, core::String name) → self::EnumWithS1
+ : super self::_EnumWithS1&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS2&_Enum&G = core::_Enum with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS2&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS2 extends self::_EnumWithS2&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS2> values = #C54;
+ static const field self::EnumWithS2 a = #C53;
+ const constructor •(core::int index, core::String name) → self::EnumWithS2
+ : super self::_EnumWithS2&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS3&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS3&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS3 extends self::_EnumWithS3&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS3> values = #C56;
+ static const field self::EnumWithS3 a = #C55;
+ const constructor •(core::int index, core::String name) → self::EnumWithS3
+ : super self::_EnumWithS3&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS4&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS4&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS4 extends self::_EnumWithS4&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS4> values = #C58;
+ static const field self::EnumWithS4 a = #C57;
+ const constructor •(core::int index, core::String name) → self::EnumWithS4
+ : super self::_EnumWithS4&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS5&_Enum&G = core::_Enum with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS5&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS5 extends self::_EnumWithS5&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS5> values = #C60;
+ static const field self::EnumWithS5 a = #C59;
+ const constructor •(core::int index, core::String name) → self::EnumWithS5
+ : super self::_EnumWithS5&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS6&_Enum&G = core::_Enum with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS6&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS6 extends self::_EnumWithS6&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS6> values = #C62;
+ static const field self::EnumWithS6 a = #C61;
+ const constructor •(core::int index, core::String name) → self::EnumWithS6
+ : super self::_EnumWithS6&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS7&_Enum&G = core::_Enum with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS7&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS7 extends self::_EnumWithS7&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS7> values = #C64;
+ static const field self::EnumWithS7 a = #C63;
+ const constructor •(core::int index, core::String name) → self::EnumWithS7
+ : super self::_EnumWithS7&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS8&_Enum&G = core::_Enum with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS8&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS8 extends self::_EnumWithS8&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS8> values = #C66;
+ static const field self::EnumWithS8 a = #C65;
+ const constructor •(core::int index, core::String name) → self::EnumWithS8
+ : super self::_EnumWithS8&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnT1 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT2 extends self::Class<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT3 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT4 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT5 extends self::Class<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT6 extends self::Class<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT7 extends self::Class<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT8 extends self::Class<core::int> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS1 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS2 extends self::G<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS3 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS4 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS5 extends self::G<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS6 extends self::G<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS7 extends self::G<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS8 extends self::G<core::int> /*isMixinDeclaration*/ {
+}
+extension ExtensionOnT1 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT2 on self::Class<dynamic> {
+}
+extension ExtensionOnT3 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT4 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT5 on self::Class<self::ConcreteClass> {
+}
+extension ExtensionOnT6 on self::Class<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnT7 on self::Class<core::Object> {
+}
+extension ExtensionOnT8 on self::Class<core::int> {
+}
+extension ExtensionOnS1 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS2 on self::G<dynamic> {
+}
+extension ExtensionOnS3 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS4 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS5 on self::G<self::ConcreteClass> {
+}
+extension ExtensionOnS6 on self::G<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnS7 on self::G<core::Object> {
+}
+extension ExtensionOnS8 on self::G<core::int> {
+}
+static method main() → dynamic {}
+static method _#F#new#tearOff<X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class<self::_#F#new#tearOff::X>
+ return new self::Class::•<self::_#F#new#tearOff::X>();
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::EnumImplementsT1 {index:#C1, _name:#C2}
+ #C4 = <self::EnumImplementsT1*>[#C3]
+ #C5 = self::EnumImplementsT2 {index:#C1, _name:#C2}
+ #C6 = <self::EnumImplementsT2*>[#C5]
+ #C7 = self::EnumImplementsT3 {index:#C1, _name:#C2}
+ #C8 = <self::EnumImplementsT3*>[#C7]
+ #C9 = self::EnumImplementsT4 {index:#C1, _name:#C2}
+ #C10 = <self::EnumImplementsT4*>[#C9]
+ #C11 = self::EnumImplementsT5 {index:#C1, _name:#C2}
+ #C12 = <self::EnumImplementsT5*>[#C11]
+ #C13 = self::EnumImplementsT6 {index:#C1, _name:#C2}
+ #C14 = <self::EnumImplementsT6*>[#C13]
+ #C15 = self::EnumImplementsT7 {index:#C1, _name:#C2}
+ #C16 = <self::EnumImplementsT7*>[#C15]
+ #C17 = self::EnumImplementsT8 {index:#C1, _name:#C2}
+ #C18 = <self::EnumImplementsT8*>[#C17]
+ #C19 = self::EnumImplementsS1 {index:#C1, _name:#C2}
+ #C20 = <self::EnumImplementsS1*>[#C19]
+ #C21 = self::EnumImplementsS2 {index:#C1, _name:#C2}
+ #C22 = <self::EnumImplementsS2*>[#C21]
+ #C23 = self::EnumImplementsS3 {index:#C1, _name:#C2}
+ #C24 = <self::EnumImplementsS3*>[#C23]
+ #C25 = self::EnumImplementsS4 {index:#C1, _name:#C2}
+ #C26 = <self::EnumImplementsS4*>[#C25]
+ #C27 = self::EnumImplementsS5 {index:#C1, _name:#C2}
+ #C28 = <self::EnumImplementsS5*>[#C27]
+ #C29 = self::EnumImplementsS6 {index:#C1, _name:#C2}
+ #C30 = <self::EnumImplementsS6*>[#C29]
+ #C31 = self::EnumImplementsS7 {index:#C1, _name:#C2}
+ #C32 = <self::EnumImplementsS7*>[#C31]
+ #C33 = self::EnumImplementsS8 {index:#C1, _name:#C2}
+ #C34 = <self::EnumImplementsS8*>[#C33]
+ #C35 = self::EnumWithT1 {index:#C1, _name:#C2}
+ #C36 = <self::EnumWithT1*>[#C35]
+ #C37 = self::EnumWithT2 {index:#C1, _name:#C2}
+ #C38 = <self::EnumWithT2*>[#C37]
+ #C39 = self::EnumWithT3 {index:#C1, _name:#C2}
+ #C40 = <self::EnumWithT3*>[#C39]
+ #C41 = self::EnumWithT4 {index:#C1, _name:#C2}
+ #C42 = <self::EnumWithT4*>[#C41]
+ #C43 = self::EnumWithT5 {index:#C1, _name:#C2}
+ #C44 = <self::EnumWithT5*>[#C43]
+ #C45 = self::EnumWithT6 {index:#C1, _name:#C2}
+ #C46 = <self::EnumWithT6*>[#C45]
+ #C47 = self::EnumWithT7 {index:#C1, _name:#C2}
+ #C48 = <self::EnumWithT7*>[#C47]
+ #C49 = self::EnumWithT8 {index:#C1, _name:#C2}
+ #C50 = <self::EnumWithT8*>[#C49]
+ #C51 = self::EnumWithS1 {index:#C1, _name:#C2}
+ #C52 = <self::EnumWithS1*>[#C51]
+ #C53 = self::EnumWithS2 {index:#C1, _name:#C2}
+ #C54 = <self::EnumWithS2*>[#C53]
+ #C55 = self::EnumWithS3 {index:#C1, _name:#C2}
+ #C56 = <self::EnumWithS3*>[#C55]
+ #C57 = self::EnumWithS4 {index:#C1, _name:#C2}
+ #C58 = <self::EnumWithS4*>[#C57]
+ #C59 = self::EnumWithS5 {index:#C1, _name:#C2}
+ #C60 = <self::EnumWithS5*>[#C59]
+ #C61 = self::EnumWithS6 {index:#C1, _name:#C2}
+ #C62 = <self::EnumWithS6*>[#C61]
+ #C63 = self::EnumWithS7 {index:#C1, _name:#C2}
+ #C64 = <self::EnumWithS7*>[#C63]
+ #C65 = self::EnumWithS8 {index:#C1, _name:#C2}
+ #C66 = <self::EnumWithS8*>[#C65]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_supertypes.dart:
+- EnumImplementsT1. (from org-dartlang-testcase:///bounds_supertypes.dart:109:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- EnumImplementsT2. (from org-dartlang-testcase:///bounds_supertypes.dart:111:6)
+- EnumImplementsT3. (from org-dartlang-testcase:///bounds_supertypes.dart:113:6)
+- EnumImplementsT4. (from org-dartlang-testcase:///bounds_supertypes.dart:115:6)
+- EnumImplementsT5. (from org-dartlang-testcase:///bounds_supertypes.dart:117:6)
+- EnumImplementsT6. (from org-dartlang-testcase:///bounds_supertypes.dart:119:6)
+- EnumImplementsT7. (from org-dartlang-testcase:///bounds_supertypes.dart:121:6)
+- EnumImplementsT8. (from org-dartlang-testcase:///bounds_supertypes.dart:123:6)
+- EnumImplementsS1. (from org-dartlang-testcase:///bounds_supertypes.dart:125:6)
+- EnumImplementsS2. (from org-dartlang-testcase:///bounds_supertypes.dart:127:6)
+- EnumImplementsS3. (from org-dartlang-testcase:///bounds_supertypes.dart:129:6)
+- EnumImplementsS4. (from org-dartlang-testcase:///bounds_supertypes.dart:131:6)
+- EnumImplementsS5. (from org-dartlang-testcase:///bounds_supertypes.dart:133:6)
+- EnumImplementsS6. (from org-dartlang-testcase:///bounds_supertypes.dart:135:6)
+- EnumImplementsS7. (from org-dartlang-testcase:///bounds_supertypes.dart:137:6)
+- EnumImplementsS8. (from org-dartlang-testcase:///bounds_supertypes.dart:139:6)
+- EnumWithT1. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- _EnumWithT1&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- EnumWithT2. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- _EnumWithT2&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- EnumWithT3. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- _EnumWithT3&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- EnumWithT4. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- _EnumWithT4&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- EnumWithT5. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- _EnumWithT5&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- EnumWithT6. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- _EnumWithT6&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- EnumWithT7. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- _EnumWithT7&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- EnumWithT8. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- _EnumWithT8&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- EnumWithS1. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- _EnumWithS1&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- EnumWithS2. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- _EnumWithS2&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- EnumWithS3. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- _EnumWithS3&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- EnumWithS4. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- _EnumWithS4&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- EnumWithS5. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- _EnumWithS5&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- EnumWithS6. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- _EnumWithS6&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- EnumWithS7. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- _EnumWithS7&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- EnumWithS8. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
+- _EnumWithS8&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.outline.expect
new file mode 100644
index 0000000..ed00b2e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.outline.expect
@@ -0,0 +1,1478 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:13:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsT1 extends F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:15:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT2 extends F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:17:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT3 extends F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:19:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT4 extends F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:25:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT7 extends F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:27:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT8 extends F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:29:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsS1 extends G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:31:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS2 extends G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:33:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS3 extends G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:35:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS4 extends G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:41:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS7 extends G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:43:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS8 extends G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:45:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsT1 implements F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:47:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT2 implements F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:49:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT3 implements F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:51:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT4 implements F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:57:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT7 implements F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:59:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT8 implements F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:61:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsS1 implements G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:63:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS2 implements G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:65:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS3 implements G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:67:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS4 implements G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:73:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS7 implements G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:75:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS8 implements G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:77:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithT1 with F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:79:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT2 with F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:81:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT3 with F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:83:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT4 with F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:89:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT7 with F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:91:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT8 with F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:109:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsT1 implements F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:111:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT2 implements F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:113:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT3 implements F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:115:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT4 implements F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:121:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT7 implements F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:123:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT8 implements F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:125:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsS1 implements G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:127:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS2 implements G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:129:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS3 implements G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:131:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS4 implements G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:137:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS7 implements G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:139:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS8 implements G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:141:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithT1 with F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:143:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT2 with F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:145:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT3 with F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:147:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT4 with F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:153:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT7 with F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:155:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT8 with F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:173:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnT1 on F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:175:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT2 on F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:177:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT3 on F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:179:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT4 on F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:185:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:187:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:189:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnS1 on G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:191:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS2 on G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:193:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS3 on G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:195:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS4 on G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:201:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:203:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:217:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:219:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:233:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:235:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:93:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithS1 with G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:95:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS2 with G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:97:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS3 with G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:99:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS4 with G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:105:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS7 with G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:107:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS8 with G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:157:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithS1 with G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:159:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS2 with G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:161:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS3 with G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:163:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS4 with G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:169:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS7 with G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:171:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS8 with G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = self::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class ExtendsT1 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT1
+ ;
+}
+class ExtendsT2 extends self::Class<dynamic> {
+ synthetic constructor •() → self::ExtendsT2
+ ;
+}
+class ExtendsT3 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT3
+ ;
+}
+class ExtendsT4 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT4
+ ;
+}
+class ExtendsT5 extends self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsT5
+ ;
+}
+class ExtendsT6 extends self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsT6
+ ;
+}
+class ExtendsT7 extends self::Class<core::Object> {
+ synthetic constructor •() → self::ExtendsT7
+ ;
+}
+class ExtendsT8 extends self::Class<core::int> {
+ synthetic constructor •() → self::ExtendsT8
+ ;
+}
+class ExtendsS1 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS1
+ ;
+}
+class ExtendsS2 extends self::G<dynamic> {
+ synthetic constructor •() → self::ExtendsS2
+ ;
+}
+class ExtendsS3 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS3
+ ;
+}
+class ExtendsS4 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS4
+ ;
+}
+class ExtendsS5 extends self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsS5
+ ;
+}
+class ExtendsS6 extends self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsS6
+ ;
+}
+class ExtendsS7 extends self::G<core::Object> {
+ synthetic constructor •() → self::ExtendsS7
+ ;
+}
+class ExtendsS8 extends self::G<core::int> {
+ synthetic constructor •() → self::ExtendsS8
+ ;
+}
+class ImplementsT1 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT1
+ ;
+}
+class ImplementsT2 extends core::Object implements self::Class<dynamic> {
+ synthetic constructor •() → self::ImplementsT2
+ ;
+}
+class ImplementsT3 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT3
+ ;
+}
+class ImplementsT4 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT4
+ ;
+}
+class ImplementsT5 extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsT5
+ ;
+}
+class ImplementsT6 extends core::Object implements self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsT6
+ ;
+}
+class ImplementsT7 extends core::Object implements self::Class<core::Object> {
+ synthetic constructor •() → self::ImplementsT7
+ ;
+}
+class ImplementsT8 extends core::Object implements self::Class<core::int> {
+ synthetic constructor •() → self::ImplementsT8
+ ;
+}
+class ImplementsS1 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS1
+ ;
+}
+class ImplementsS2 extends core::Object implements self::G<dynamic> {
+ synthetic constructor •() → self::ImplementsS2
+ ;
+}
+class ImplementsS3 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS3
+ ;
+}
+class ImplementsS4 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS4
+ ;
+}
+class ImplementsS5 extends core::Object implements self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsS5
+ ;
+}
+class ImplementsS6 extends core::Object implements self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsS6
+ ;
+}
+class ImplementsS7 extends core::Object implements self::G<core::Object> {
+ synthetic constructor •() → self::ImplementsS7
+ ;
+}
+class ImplementsS8 extends core::Object implements self::G<core::int> {
+ synthetic constructor •() → self::ImplementsS8
+ ;
+}
+abstract class _WithT1&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT1&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT1 extends self::_WithT1&Object&F {
+ synthetic constructor •() → self::WithT1
+ ;
+}
+abstract class _WithT2&Object&F = core::Object with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT2&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT2 extends self::_WithT2&Object&F {
+ synthetic constructor •() → self::WithT2
+ ;
+}
+abstract class _WithT3&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT3&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT3 extends self::_WithT3&Object&F {
+ synthetic constructor •() → self::WithT3
+ ;
+}
+abstract class _WithT4&Object&F = core::Object with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT4&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT4 extends self::_WithT4&Object&F {
+ synthetic constructor •() → self::WithT4
+ ;
+}
+abstract class _WithT5&Object&F = core::Object with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT5&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT5 extends self::_WithT5&Object&F {
+ synthetic constructor •() → self::WithT5
+ ;
+}
+abstract class _WithT6&Object&F = core::Object with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT6&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT6 extends self::_WithT6&Object&F {
+ synthetic constructor •() → self::WithT6
+ ;
+}
+abstract class _WithT7&Object&F = core::Object with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT7&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT7 extends self::_WithT7&Object&F {
+ synthetic constructor •() → self::WithT7
+ ;
+}
+abstract class _WithT8&Object&F = core::Object with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT8&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT8 extends self::_WithT8&Object&F {
+ synthetic constructor •() → self::WithT8
+ ;
+}
+abstract class _WithS1&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS1&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS1 extends self::_WithS1&Object&G {
+ synthetic constructor •() → self::WithS1
+ ;
+}
+abstract class _WithS2&Object&G = core::Object with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS2&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS2 extends self::_WithS2&Object&G {
+ synthetic constructor •() → self::WithS2
+ ;
+}
+abstract class _WithS3&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS3&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS3 extends self::_WithS3&Object&G {
+ synthetic constructor •() → self::WithS3
+ ;
+}
+abstract class _WithS4&Object&G = core::Object with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS4&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS4 extends self::_WithS4&Object&G {
+ synthetic constructor •() → self::WithS4
+ ;
+}
+abstract class _WithS5&Object&G = core::Object with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS5&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS5 extends self::_WithS5&Object&G {
+ synthetic constructor •() → self::WithS5
+ ;
+}
+abstract class _WithS6&Object&G = core::Object with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS6&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS6 extends self::_WithS6&Object&G {
+ synthetic constructor •() → self::WithS6
+ ;
+}
+abstract class _WithS7&Object&G = core::Object with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS7&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS7 extends self::_WithS7&Object&G {
+ synthetic constructor •() → self::WithS7
+ ;
+}
+abstract class _WithS8&Object&G = core::Object with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS8&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS8 extends self::_WithS8&Object&G {
+ synthetic constructor •() → self::WithS8
+ ;
+}
+class EnumImplementsT1 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT1> values = const <self::EnumImplementsT1>[self::EnumImplementsT1::a];
+ static const field self::EnumImplementsT1 a = const self::EnumImplementsT1::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT2 extends core::_Enum implements self::Class<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT2> values = const <self::EnumImplementsT2>[self::EnumImplementsT2::a];
+ static const field self::EnumImplementsT2 a = const self::EnumImplementsT2::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT3 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT3> values = const <self::EnumImplementsT3>[self::EnumImplementsT3::a];
+ static const field self::EnumImplementsT3 a = const self::EnumImplementsT3::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT4 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT4> values = const <self::EnumImplementsT4>[self::EnumImplementsT4::a];
+ static const field self::EnumImplementsT4 a = const self::EnumImplementsT4::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT5 extends core::_Enum implements self::Class<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT5> values = const <self::EnumImplementsT5>[self::EnumImplementsT5::a];
+ static const field self::EnumImplementsT5 a = const self::EnumImplementsT5::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT6 extends core::_Enum implements self::Class<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT6> values = const <self::EnumImplementsT6>[self::EnumImplementsT6::a];
+ static const field self::EnumImplementsT6 a = const self::EnumImplementsT6::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT7 extends core::_Enum implements self::Class<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT7> values = const <self::EnumImplementsT7>[self::EnumImplementsT7::a];
+ static const field self::EnumImplementsT7 a = const self::EnumImplementsT7::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT8 extends core::_Enum implements self::Class<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT8> values = const <self::EnumImplementsT8>[self::EnumImplementsT8::a];
+ static const field self::EnumImplementsT8 a = const self::EnumImplementsT8::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT8.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS1 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS1> values = const <self::EnumImplementsS1>[self::EnumImplementsS1::a];
+ static const field self::EnumImplementsS1 a = const self::EnumImplementsS1::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS2 extends core::_Enum implements self::G<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS2> values = const <self::EnumImplementsS2>[self::EnumImplementsS2::a];
+ static const field self::EnumImplementsS2 a = const self::EnumImplementsS2::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS3 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS3> values = const <self::EnumImplementsS3>[self::EnumImplementsS3::a];
+ static const field self::EnumImplementsS3 a = const self::EnumImplementsS3::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS4 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS4> values = const <self::EnumImplementsS4>[self::EnumImplementsS4::a];
+ static const field self::EnumImplementsS4 a = const self::EnumImplementsS4::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS5 extends core::_Enum implements self::G<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS5> values = const <self::EnumImplementsS5>[self::EnumImplementsS5::a];
+ static const field self::EnumImplementsS5 a = const self::EnumImplementsS5::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS6 extends core::_Enum implements self::G<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS6> values = const <self::EnumImplementsS6>[self::EnumImplementsS6::a];
+ static const field self::EnumImplementsS6 a = const self::EnumImplementsS6::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS7 extends core::_Enum implements self::G<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS7> values = const <self::EnumImplementsS7>[self::EnumImplementsS7::a];
+ static const field self::EnumImplementsS7 a = const self::EnumImplementsS7::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS8 extends core::_Enum implements self::G<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS8> values = const <self::EnumImplementsS8>[self::EnumImplementsS8::a];
+ static const field self::EnumImplementsS8 a = const self::EnumImplementsS8::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT1&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT1&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT1 extends self::_EnumWithT1&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT1> values = const <self::EnumWithT1>[self::EnumWithT1::a];
+ static const field self::EnumWithT1 a = const self::EnumWithT1::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT1
+ ;
+ method toString() → core::String
+ return "EnumWithT1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT2&_Enum&F = core::_Enum with self::Class<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT2&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT2 extends self::_EnumWithT2&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT2> values = const <self::EnumWithT2>[self::EnumWithT2::a];
+ static const field self::EnumWithT2 a = const self::EnumWithT2::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT2
+ ;
+ method toString() → core::String
+ return "EnumWithT2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT3&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT3&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT3 extends self::_EnumWithT3&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT3> values = const <self::EnumWithT3>[self::EnumWithT3::a];
+ static const field self::EnumWithT3 a = const self::EnumWithT3::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT3
+ ;
+ method toString() → core::String
+ return "EnumWithT3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT4&_Enum&F = core::_Enum with self::Class<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT4&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT4 extends self::_EnumWithT4&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT4> values = const <self::EnumWithT4>[self::EnumWithT4::a];
+ static const field self::EnumWithT4 a = const self::EnumWithT4::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT4
+ ;
+ method toString() → core::String
+ return "EnumWithT4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT5&_Enum&F = core::_Enum with self::Class<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT5&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT5 extends self::_EnumWithT5&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT5> values = const <self::EnumWithT5>[self::EnumWithT5::a];
+ static const field self::EnumWithT5 a = const self::EnumWithT5::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT5
+ ;
+ method toString() → core::String
+ return "EnumWithT5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT6&_Enum&F = core::_Enum with self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT6&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT6 extends self::_EnumWithT6&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT6> values = const <self::EnumWithT6>[self::EnumWithT6::a];
+ static const field self::EnumWithT6 a = const self::EnumWithT6::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT6
+ ;
+ method toString() → core::String
+ return "EnumWithT6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT7&_Enum&F = core::_Enum with self::Class<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT7&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT7 extends self::_EnumWithT7&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT7> values = const <self::EnumWithT7>[self::EnumWithT7::a];
+ static const field self::EnumWithT7 a = const self::EnumWithT7::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT7
+ ;
+ method toString() → core::String
+ return "EnumWithT7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT8&_Enum&F = core::_Enum with self::Class<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT8&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT8 extends self::_EnumWithT8&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT8> values = const <self::EnumWithT8>[self::EnumWithT8::a];
+ static const field self::EnumWithT8 a = const self::EnumWithT8::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithT8
+ ;
+ method toString() → core::String
+ return "EnumWithT8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS1&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS1&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS1 extends self::_EnumWithS1&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS1> values = const <self::EnumWithS1>[self::EnumWithS1::a];
+ static const field self::EnumWithS1 a = const self::EnumWithS1::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS1
+ ;
+ method toString() → core::String
+ return "EnumWithS1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS2&_Enum&G = core::_Enum with self::G<dynamic> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS2&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS2 extends self::_EnumWithS2&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS2> values = const <self::EnumWithS2>[self::EnumWithS2::a];
+ static const field self::EnumWithS2 a = const self::EnumWithS2::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS2
+ ;
+ method toString() → core::String
+ return "EnumWithS2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS3&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS3&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS3 extends self::_EnumWithS3&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS3> values = const <self::EnumWithS3>[self::EnumWithS3::a];
+ static const field self::EnumWithS3 a = const self::EnumWithS3::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS3
+ ;
+ method toString() → core::String
+ return "EnumWithS3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS4&_Enum&G = core::_Enum with self::G<self::Class<dynamic>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS4&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS4 extends self::_EnumWithS4&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS4> values = const <self::EnumWithS4>[self::EnumWithS4::a];
+ static const field self::EnumWithS4 a = const self::EnumWithS4::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS4
+ ;
+ method toString() → core::String
+ return "EnumWithS4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS5&_Enum&G = core::_Enum with self::G<self::ConcreteClass> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS5&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS5 extends self::_EnumWithS5&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS5> values = const <self::EnumWithS5>[self::EnumWithS5::a];
+ static const field self::EnumWithS5 a = const self::EnumWithS5::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS5
+ ;
+ method toString() → core::String
+ return "EnumWithS5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS6&_Enum&G = core::_Enum with self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS6&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS6 extends self::_EnumWithS6&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS6> values = const <self::EnumWithS6>[self::EnumWithS6::a];
+ static const field self::EnumWithS6 a = const self::EnumWithS6::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS6
+ ;
+ method toString() → core::String
+ return "EnumWithS6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS7&_Enum&G = core::_Enum with self::G<core::Object> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS7&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS7 extends self::_EnumWithS7&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS7> values = const <self::EnumWithS7>[self::EnumWithS7::a];
+ static const field self::EnumWithS7 a = const self::EnumWithS7::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS7
+ ;
+ method toString() → core::String
+ return "EnumWithS7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS8&_Enum&G = core::_Enum with self::G<core::int> /*isAnonymousMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS8&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS8 extends self::_EnumWithS8&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS8> values = const <self::EnumWithS8>[self::EnumWithS8::a];
+ static const field self::EnumWithS8 a = const self::EnumWithS8::•(0, "a");
+ const constructor •(core::int index, core::String name) → self::EnumWithS8
+ ;
+ method toString() → core::String
+ return "EnumWithS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnT1 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT2 extends self::Class<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT3 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT4 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT5 extends self::Class<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT6 extends self::Class<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT7 extends self::Class<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT8 extends self::Class<core::int> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS1 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS2 extends self::G<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS3 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS4 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS5 extends self::G<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS6 extends self::G<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS7 extends self::G<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS8 extends self::G<core::int> /*isMixinDeclaration*/ {
+}
+extension ExtensionOnT1 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT2 on self::Class<dynamic> {
+}
+extension ExtensionOnT3 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT4 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT5 on self::Class<self::ConcreteClass> {
+}
+extension ExtensionOnT6 on self::Class<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnT7 on self::Class<core::Object> {
+}
+extension ExtensionOnT8 on self::Class<core::int> {
+}
+extension ExtensionOnS1 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS2 on self::G<dynamic> {
+}
+extension ExtensionOnS3 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS4 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS5 on self::G<self::ConcreteClass> {
+}
+extension ExtensionOnS6 on self::G<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnS7 on self::G<core::Object> {
+}
+extension ExtensionOnS8 on self::G<core::int> {
+}
+static method main() → dynamic
+ ;
+static method _#F#new#tearOff<X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class<self::_#F#new#tearOff::X>
+ return new self::Class::•<self::_#F#new#tearOff::X>();
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:109:6 -> ListConstant(const <EnumImplementsT1*>[const EnumImplementsT1{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:109:50 -> InstanceConstant(const EnumImplementsT1{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:111:6 -> ListConstant(const <EnumImplementsT2*>[const EnumImplementsT2{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:111:59 -> InstanceConstant(const EnumImplementsT2{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:113:6 -> ListConstant(const <EnumImplementsT3*>[const EnumImplementsT3{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:113:57 -> InstanceConstant(const EnumImplementsT3{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:115:6 -> ListConstant(const <EnumImplementsT4*>[const EnumImplementsT4{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:115:66 -> InstanceConstant(const EnumImplementsT4{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:117:6 -> ListConstant(const <EnumImplementsT5*>[const EnumImplementsT5{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:117:62 -> InstanceConstant(const EnumImplementsT5{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:119:6 -> ListConstant(const <EnumImplementsT6*>[const EnumImplementsT6{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:119:69 -> InstanceConstant(const EnumImplementsT6{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:121:6 -> ListConstant(const <EnumImplementsT7*>[const EnumImplementsT7{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:121:58 -> InstanceConstant(const EnumImplementsT7{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:123:6 -> ListConstant(const <EnumImplementsT8*>[const EnumImplementsT8{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:123:55 -> InstanceConstant(const EnumImplementsT8{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:125:6 -> ListConstant(const <EnumImplementsS1*>[const EnumImplementsS1{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:125:50 -> InstanceConstant(const EnumImplementsS1{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:127:6 -> ListConstant(const <EnumImplementsS2*>[const EnumImplementsS2{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:127:59 -> InstanceConstant(const EnumImplementsS2{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:129:6 -> ListConstant(const <EnumImplementsS3*>[const EnumImplementsS3{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:129:57 -> InstanceConstant(const EnumImplementsS3{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:131:6 -> ListConstant(const <EnumImplementsS4*>[const EnumImplementsS4{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:131:66 -> InstanceConstant(const EnumImplementsS4{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:133:6 -> ListConstant(const <EnumImplementsS5*>[const EnumImplementsS5{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:133:62 -> InstanceConstant(const EnumImplementsS5{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:135:6 -> ListConstant(const <EnumImplementsS6*>[const EnumImplementsS6{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:135:69 -> InstanceConstant(const EnumImplementsS6{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:137:6 -> ListConstant(const <EnumImplementsS7*>[const EnumImplementsS7{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:137:58 -> InstanceConstant(const EnumImplementsS7{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:139:6 -> ListConstant(const <EnumImplementsS8*>[const EnumImplementsS8{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:139:55 -> InstanceConstant(const EnumImplementsS8{_Enum.index: 0, _Enum._name: "a"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:141:6 -> ListConstant(const <EnumWithT1*>[const EnumWithT1{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:141:38 -> InstanceConstant(const EnumWithT1{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:143:6 -> ListConstant(const <EnumWithT2*>[const EnumWithT2{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:143:47 -> InstanceConstant(const EnumWithT2{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:145:6 -> ListConstant(const <EnumWithT3*>[const EnumWithT3{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:145:45 -> InstanceConstant(const EnumWithT3{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:147:6 -> ListConstant(const <EnumWithT4*>[const EnumWithT4{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:147:54 -> InstanceConstant(const EnumWithT4{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:149:6 -> ListConstant(const <EnumWithT5*>[const EnumWithT5{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:149:50 -> InstanceConstant(const EnumWithT5{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:151:6 -> ListConstant(const <EnumWithT6*>[const EnumWithT6{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:151:57 -> InstanceConstant(const EnumWithT6{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:153:6 -> ListConstant(const <EnumWithT7*>[const EnumWithT7{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:153:46 -> InstanceConstant(const EnumWithT7{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:155:6 -> ListConstant(const <EnumWithT8*>[const EnumWithT8{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:155:43 -> InstanceConstant(const EnumWithT8{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:157:6 -> ListConstant(const <EnumWithS1*>[const EnumWithS1{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:157:38 -> InstanceConstant(const EnumWithS1{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:159:6 -> ListConstant(const <EnumWithS2*>[const EnumWithS2{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:159:47 -> InstanceConstant(const EnumWithS2{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:161:6 -> ListConstant(const <EnumWithS3*>[const EnumWithS3{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:161:45 -> InstanceConstant(const EnumWithS3{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:163:6 -> ListConstant(const <EnumWithS4*>[const EnumWithS4{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:163:54 -> InstanceConstant(const EnumWithS4{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:165:6 -> ListConstant(const <EnumWithS5*>[const EnumWithS5{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:165:50 -> InstanceConstant(const EnumWithS5{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:167:6 -> ListConstant(const <EnumWithS6*>[const EnumWithS6{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:167:57 -> InstanceConstant(const EnumWithS6{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:169:6 -> ListConstant(const <EnumWithS7*>[const EnumWithS7{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:169:46 -> InstanceConstant(const EnumWithS7{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_supertypes.dart:171:6 -> ListConstant(const <EnumWithS8*>[const EnumWithS8{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_supertypes.dart:171:43 -> InstanceConstant(const EnumWithS8{})
+Extra constant evaluation: evaluated: 225, effectively constant: 64
diff --git a/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.transformed.expect
new file mode 100644
index 0000000..c15302b
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_supertypes.dart.weak.transformed.expect
@@ -0,0 +1,1599 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:13:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsT1 extends F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:15:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT2 extends F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:17:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT3 extends F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:19:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT4 extends F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:25:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT7 extends F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:27:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsT8 extends F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:29:25: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ExtendsS1 extends G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:31:25: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS2 extends G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:33:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS3 extends G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:35:25: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS4 extends G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:41:25: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS7 extends G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:43:25: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ExtendsS8 extends G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:45:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsT1 implements F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:47:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT2 implements F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:49:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT3 implements F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:51:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT4 implements F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:57:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT7 implements F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:59:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsT8 implements F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:61:31: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class ImplementsS1 implements G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:63:31: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS2 implements G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:65:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS3 implements G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:67:31: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS4 implements G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:73:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS7 implements G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:75:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class ImplementsS8 implements G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:77:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithT1 with F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:79:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT2 with F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:81:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT3 with F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:83:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT4 with F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:89:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT7 with F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:91:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithT8 with F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:109:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsT1 implements F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:111:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT2 implements F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:113:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT3 implements F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:115:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT4 implements F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:121:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT7 implements F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:123:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsT8 implements F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:125:34: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumImplementsS1 implements G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:127:34: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS2 implements G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:129:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS3 implements G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:131:34: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS4 implements G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:137:34: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS7 implements G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:139:34: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumImplementsS8 implements G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:141:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithT1 with F /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:143:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT2 with F<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:145:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT3 with F<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:147:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT4 with F<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:153:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT7 with F<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:155:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithT8 with F<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:173:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnT1 on F {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:175:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT2 on F<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:177:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT3 on F<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:179:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT4 on F<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:185:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:187:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:189:20: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// mixin MixinOnS1 on G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:191:20: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS2 on G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:193:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS3 on G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:195:20: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS4 on G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:201:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:203:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// mixin MixinOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:217:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT7 on F<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:219:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnT8 on F<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = Class<X>;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:233:28: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS7 on G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:235:28: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// extension ExtensionOnS8 on G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:93:19: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// class WithS1 with G {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:95:19: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS2 with G<dynamic> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:97:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS3 with G<Class> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:99:19: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS4 with G<Class<dynamic>> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:105:19: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS7 with G<Object> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:107:19: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// class WithS8 with G<int> {} // Error
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:157:22: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// enum EnumWithS1 with G /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:159:22: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS2 with G<dynamic> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:161:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS3 with G<Class> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:163:22: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS4 with G<Class<dynamic>> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:169:22: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS7 with G<Object> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_supertypes.dart:171:22: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_supertypes.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// enum EnumWithS8 with G<int> /* Error */ { a }
+// ^
+// pkg/front_end/testcases/general/bounds_supertypes.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = self::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class ExtendsT1 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT1
+ : super self::Class::•()
+ ;
+}
+class ExtendsT2 extends self::Class<dynamic> {
+ synthetic constructor •() → self::ExtendsT2
+ : super self::Class::•()
+ ;
+}
+class ExtendsT3 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT3
+ : super self::Class::•()
+ ;
+}
+class ExtendsT4 extends self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsT4
+ : super self::Class::•()
+ ;
+}
+class ExtendsT5 extends self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsT5
+ : super self::Class::•()
+ ;
+}
+class ExtendsT6 extends self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsT6
+ : super self::Class::•()
+ ;
+}
+class ExtendsT7 extends self::Class<core::Object> {
+ synthetic constructor •() → self::ExtendsT7
+ : super self::Class::•()
+ ;
+}
+class ExtendsT8 extends self::Class<core::int> {
+ synthetic constructor •() → self::ExtendsT8
+ : super self::Class::•()
+ ;
+}
+class ExtendsS1 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS1
+ : super self::G::•()
+ ;
+}
+class ExtendsS2 extends self::G<dynamic> {
+ synthetic constructor •() → self::ExtendsS2
+ : super self::G::•()
+ ;
+}
+class ExtendsS3 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS3
+ : super self::G::•()
+ ;
+}
+class ExtendsS4 extends self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ExtendsS4
+ : super self::G::•()
+ ;
+}
+class ExtendsS5 extends self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ExtendsS5
+ : super self::G::•()
+ ;
+}
+class ExtendsS6 extends self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ExtendsS6
+ : super self::G::•()
+ ;
+}
+class ExtendsS7 extends self::G<core::Object> {
+ synthetic constructor •() → self::ExtendsS7
+ : super self::G::•()
+ ;
+}
+class ExtendsS8 extends self::G<core::int> {
+ synthetic constructor •() → self::ExtendsS8
+ : super self::G::•()
+ ;
+}
+class ImplementsT1 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT1
+ : super core::Object::•()
+ ;
+}
+class ImplementsT2 extends core::Object implements self::Class<dynamic> {
+ synthetic constructor •() → self::ImplementsT2
+ : super core::Object::•()
+ ;
+}
+class ImplementsT3 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT3
+ : super core::Object::•()
+ ;
+}
+class ImplementsT4 extends core::Object implements self::Class<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsT4
+ : super core::Object::•()
+ ;
+}
+class ImplementsT5 extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsT5
+ : super core::Object::•()
+ ;
+}
+class ImplementsT6 extends core::Object implements self::Class<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsT6
+ : super core::Object::•()
+ ;
+}
+class ImplementsT7 extends core::Object implements self::Class<core::Object> {
+ synthetic constructor •() → self::ImplementsT7
+ : super core::Object::•()
+ ;
+}
+class ImplementsT8 extends core::Object implements self::Class<core::int> {
+ synthetic constructor •() → self::ImplementsT8
+ : super core::Object::•()
+ ;
+}
+class ImplementsS1 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS1
+ : super core::Object::•()
+ ;
+}
+class ImplementsS2 extends core::Object implements self::G<dynamic> {
+ synthetic constructor •() → self::ImplementsS2
+ : super core::Object::•()
+ ;
+}
+class ImplementsS3 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS3
+ : super core::Object::•()
+ ;
+}
+class ImplementsS4 extends core::Object implements self::G<self::Class<dynamic>> {
+ synthetic constructor •() → self::ImplementsS4
+ : super core::Object::•()
+ ;
+}
+class ImplementsS5 extends core::Object implements self::G<self::ConcreteClass> {
+ synthetic constructor •() → self::ImplementsS5
+ : super core::Object::•()
+ ;
+}
+class ImplementsS6 extends core::Object implements self::G<self::Class<self::ConcreteClass>> {
+ synthetic constructor •() → self::ImplementsS6
+ : super core::Object::•()
+ ;
+}
+class ImplementsS7 extends core::Object implements self::G<core::Object> {
+ synthetic constructor •() → self::ImplementsS7
+ : super core::Object::•()
+ ;
+}
+class ImplementsS8 extends core::Object implements self::G<core::int> {
+ synthetic constructor •() → self::ImplementsS8
+ : super core::Object::•()
+ ;
+}
+abstract class _WithT1&Object&F extends core::Object implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT1&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT1 extends self::_WithT1&Object&F {
+ synthetic constructor •() → self::WithT1
+ : super self::_WithT1&Object&F::•()
+ ;
+}
+abstract class _WithT2&Object&F extends core::Object implements self::Class<dynamic> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT2&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT2 extends self::_WithT2&Object&F {
+ synthetic constructor •() → self::WithT2
+ : super self::_WithT2&Object&F::•()
+ ;
+}
+abstract class _WithT3&Object&F extends core::Object implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT3&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT3 extends self::_WithT3&Object&F {
+ synthetic constructor •() → self::WithT3
+ : super self::_WithT3&Object&F::•()
+ ;
+}
+abstract class _WithT4&Object&F extends core::Object implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT4&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT4 extends self::_WithT4&Object&F {
+ synthetic constructor •() → self::WithT4
+ : super self::_WithT4&Object&F::•()
+ ;
+}
+abstract class _WithT5&Object&F extends core::Object implements self::Class<self::ConcreteClass> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT5&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT5 extends self::_WithT5&Object&F {
+ synthetic constructor •() → self::WithT5
+ : super self::_WithT5&Object&F::•()
+ ;
+}
+abstract class _WithT6&Object&F extends core::Object implements self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT6&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT6 extends self::_WithT6&Object&F {
+ synthetic constructor •() → self::WithT6
+ : super self::_WithT6&Object&F::•()
+ ;
+}
+abstract class _WithT7&Object&F extends core::Object implements self::Class<core::Object> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT7&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT7 extends self::_WithT7&Object&F {
+ synthetic constructor •() → self::WithT7
+ : super self::_WithT7&Object&F::•()
+ ;
+}
+abstract class _WithT8&Object&F extends core::Object implements self::Class<core::int> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithT8&Object&F
+ : super core::Object::•()
+ ;
+}
+class WithT8 extends self::_WithT8&Object&F {
+ synthetic constructor •() → self::WithT8
+ : super self::_WithT8&Object&F::•()
+ ;
+}
+abstract class _WithS1&Object&G extends core::Object implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS1&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS1 extends self::_WithS1&Object&G {
+ synthetic constructor •() → self::WithS1
+ : super self::_WithS1&Object&G::•()
+ ;
+}
+abstract class _WithS2&Object&G extends core::Object implements self::G<dynamic> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS2&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS2 extends self::_WithS2&Object&G {
+ synthetic constructor •() → self::WithS2
+ : super self::_WithS2&Object&G::•()
+ ;
+}
+abstract class _WithS3&Object&G extends core::Object implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS3&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS3 extends self::_WithS3&Object&G {
+ synthetic constructor •() → self::WithS3
+ : super self::_WithS3&Object&G::•()
+ ;
+}
+abstract class _WithS4&Object&G extends core::Object implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS4&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS4 extends self::_WithS4&Object&G {
+ synthetic constructor •() → self::WithS4
+ : super self::_WithS4&Object&G::•()
+ ;
+}
+abstract class _WithS5&Object&G extends core::Object implements self::G<self::ConcreteClass> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS5&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS5 extends self::_WithS5&Object&G {
+ synthetic constructor •() → self::WithS5
+ : super self::_WithS5&Object&G::•()
+ ;
+}
+abstract class _WithS6&Object&G extends core::Object implements self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS6&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS6 extends self::_WithS6&Object&G {
+ synthetic constructor •() → self::WithS6
+ : super self::_WithS6&Object&G::•()
+ ;
+}
+abstract class _WithS7&Object&G extends core::Object implements self::G<core::Object> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS7&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS7 extends self::_WithS7&Object&G {
+ synthetic constructor •() → self::WithS7
+ : super self::_WithS7&Object&G::•()
+ ;
+}
+abstract class _WithS8&Object&G extends core::Object implements self::G<core::int> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::_WithS8&Object&G
+ : super core::Object::•()
+ ;
+}
+class WithS8 extends self::_WithS8&Object&G {
+ synthetic constructor •() → self::WithS8
+ : super self::_WithS8&Object&G::•()
+ ;
+}
+class EnumImplementsT1 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT1> values = #C4;
+ static const field self::EnumImplementsT1 a = #C3;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT2 extends core::_Enum implements self::Class<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT2> values = #C6;
+ static const field self::EnumImplementsT2 a = #C5;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT3 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT3> values = #C8;
+ static const field self::EnumImplementsT3 a = #C7;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT4 extends core::_Enum implements self::Class<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT4> values = #C10;
+ static const field self::EnumImplementsT4 a = #C9;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT5 extends core::_Enum implements self::Class<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT5> values = #C12;
+ static const field self::EnumImplementsT5 a = #C11;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT6 extends core::_Enum implements self::Class<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT6> values = #C14;
+ static const field self::EnumImplementsT6 a = #C13;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT7 extends core::_Enum implements self::Class<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT7> values = #C16;
+ static const field self::EnumImplementsT7 a = #C15;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsT8 extends core::_Enum implements self::Class<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsT8> values = #C18;
+ static const field self::EnumImplementsT8 a = #C17;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsT8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsT8.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS1 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS1> values = #C20;
+ static const field self::EnumImplementsS1 a = #C19;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS1
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS1.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS2 extends core::_Enum implements self::G<dynamic> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS2> values = #C22;
+ static const field self::EnumImplementsS2 a = #C21;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS2
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS2.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS3 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS3> values = #C24;
+ static const field self::EnumImplementsS3 a = #C23;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS3
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS3.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS4 extends core::_Enum implements self::G<self::Class<dynamic>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS4> values = #C26;
+ static const field self::EnumImplementsS4 a = #C25;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS4
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS4.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS5 extends core::_Enum implements self::G<self::ConcreteClass> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS5> values = #C28;
+ static const field self::EnumImplementsS5 a = #C27;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS5
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS5.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS6 extends core::_Enum implements self::G<self::Class<self::ConcreteClass>> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS6> values = #C30;
+ static const field self::EnumImplementsS6 a = #C29;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS6
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS6.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS7 extends core::_Enum implements self::G<core::Object> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS7> values = #C32;
+ static const field self::EnumImplementsS7 a = #C31;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS7
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS7.${this.{core::_Enum::_name}{core::String}}";
+}
+class EnumImplementsS8 extends core::_Enum implements self::G<core::int> /*isEnum*/ {
+ static const field core::List<self::EnumImplementsS8> values = #C34;
+ static const field self::EnumImplementsS8 a = #C33;
+ const constructor •(core::int index, core::String name) → self::EnumImplementsS8
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumImplementsS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT1&_Enum&F extends core::_Enum implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT1&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT1 extends self::_EnumWithT1&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT1> values = #C36;
+ static const field self::EnumWithT1 a = #C35;
+ const constructor •(core::int index, core::String name) → self::EnumWithT1
+ : super self::_EnumWithT1&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT2&_Enum&F extends core::_Enum implements self::Class<dynamic> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT2&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT2 extends self::_EnumWithT2&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT2> values = #C38;
+ static const field self::EnumWithT2 a = #C37;
+ const constructor •(core::int index, core::String name) → self::EnumWithT2
+ : super self::_EnumWithT2&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT3&_Enum&F extends core::_Enum implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT3&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT3 extends self::_EnumWithT3&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT3> values = #C40;
+ static const field self::EnumWithT3 a = #C39;
+ const constructor •(core::int index, core::String name) → self::EnumWithT3
+ : super self::_EnumWithT3&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT4&_Enum&F extends core::_Enum implements self::Class<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT4&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT4 extends self::_EnumWithT4&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT4> values = #C42;
+ static const field self::EnumWithT4 a = #C41;
+ const constructor •(core::int index, core::String name) → self::EnumWithT4
+ : super self::_EnumWithT4&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT5&_Enum&F extends core::_Enum implements self::Class<self::ConcreteClass> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT5&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT5 extends self::_EnumWithT5&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT5> values = #C44;
+ static const field self::EnumWithT5 a = #C43;
+ const constructor •(core::int index, core::String name) → self::EnumWithT5
+ : super self::_EnumWithT5&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT6&_Enum&F extends core::_Enum implements self::Class<self::Class<self::ConcreteClass>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT6&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT6 extends self::_EnumWithT6&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT6> values = #C46;
+ static const field self::EnumWithT6 a = #C45;
+ const constructor •(core::int index, core::String name) → self::EnumWithT6
+ : super self::_EnumWithT6&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT7&_Enum&F extends core::_Enum implements self::Class<core::Object> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT7&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT7 extends self::_EnumWithT7&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT7> values = #C48;
+ static const field self::EnumWithT7 a = #C47;
+ const constructor •(core::int index, core::String name) → self::EnumWithT7
+ : super self::_EnumWithT7&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithT8&_Enum&F extends core::_Enum implements self::Class<core::int> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithT8&_Enum&F
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithT8 extends self::_EnumWithT8&_Enum&F /*isEnum*/ {
+ static const field core::List<self::EnumWithT8> values = #C50;
+ static const field self::EnumWithT8 a = #C49;
+ const constructor •(core::int index, core::String name) → self::EnumWithT8
+ : super self::_EnumWithT8&_Enum&F::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithT8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS1&_Enum&G extends core::_Enum implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS1&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS1 extends self::_EnumWithS1&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS1> values = #C52;
+ static const field self::EnumWithS1 a = #C51;
+ const constructor •(core::int index, core::String name) → self::EnumWithS1
+ : super self::_EnumWithS1&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS1.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS2&_Enum&G extends core::_Enum implements self::G<dynamic> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS2&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS2 extends self::_EnumWithS2&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS2> values = #C54;
+ static const field self::EnumWithS2 a = #C53;
+ const constructor •(core::int index, core::String name) → self::EnumWithS2
+ : super self::_EnumWithS2&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS2.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS3&_Enum&G extends core::_Enum implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS3&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS3 extends self::_EnumWithS3&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS3> values = #C56;
+ static const field self::EnumWithS3 a = #C55;
+ const constructor •(core::int index, core::String name) → self::EnumWithS3
+ : super self::_EnumWithS3&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS3.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS4&_Enum&G extends core::_Enum implements self::G<self::Class<dynamic>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS4&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS4 extends self::_EnumWithS4&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS4> values = #C58;
+ static const field self::EnumWithS4 a = #C57;
+ const constructor •(core::int index, core::String name) → self::EnumWithS4
+ : super self::_EnumWithS4&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS4.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS5&_Enum&G extends core::_Enum implements self::G<self::ConcreteClass> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS5&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS5 extends self::_EnumWithS5&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS5> values = #C60;
+ static const field self::EnumWithS5 a = #C59;
+ const constructor •(core::int index, core::String name) → self::EnumWithS5
+ : super self::_EnumWithS5&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS5.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS6&_Enum&G extends core::_Enum implements self::G<self::Class<self::ConcreteClass>> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS6&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS6 extends self::_EnumWithS6&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS6> values = #C62;
+ static const field self::EnumWithS6 a = #C61;
+ const constructor •(core::int index, core::String name) → self::EnumWithS6
+ : super self::_EnumWithS6&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS6.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS7&_Enum&G extends core::_Enum implements self::G<core::Object> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS7&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS7 extends self::_EnumWithS7&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS7> values = #C64;
+ static const field self::EnumWithS7 a = #C63;
+ const constructor •(core::int index, core::String name) → self::EnumWithS7
+ : super self::_EnumWithS7&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS7.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _EnumWithS8&_Enum&G extends core::_Enum implements self::G<core::int> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •(core::int index, core::String _name) → self::_EnumWithS8&_Enum&G
+ : super core::_Enum::•(index, _name)
+ ;
+}
+class EnumWithS8 extends self::_EnumWithS8&_Enum&G /*isEnum*/ {
+ static const field core::List<self::EnumWithS8> values = #C66;
+ static const field self::EnumWithS8 a = #C65;
+ const constructor •(core::int index, core::String name) → self::EnumWithS8
+ : super self::_EnumWithS8&_Enum&G::•(index, name)
+ ;
+ method toString() → core::String
+ return "EnumWithS8.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnT1 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT2 extends self::Class<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT3 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT4 extends self::Class<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT5 extends self::Class<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT6 extends self::Class<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT7 extends self::Class<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnT8 extends self::Class<core::int> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS1 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS2 extends self::G<dynamic> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS3 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS4 extends self::G<self::Class<dynamic>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS5 extends self::G<self::ConcreteClass> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS6 extends self::G<self::Class<self::ConcreteClass>> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS7 extends self::G<core::Object> /*isMixinDeclaration*/ {
+}
+abstract class MixinOnS8 extends self::G<core::int> /*isMixinDeclaration*/ {
+}
+extension ExtensionOnT1 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT2 on self::Class<dynamic> {
+}
+extension ExtensionOnT3 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT4 on self::Class<self::Class<dynamic>> {
+}
+extension ExtensionOnT5 on self::Class<self::ConcreteClass> {
+}
+extension ExtensionOnT6 on self::Class<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnT7 on self::Class<core::Object> {
+}
+extension ExtensionOnT8 on self::Class<core::int> {
+}
+extension ExtensionOnS1 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS2 on self::G<dynamic> {
+}
+extension ExtensionOnS3 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS4 on self::G<self::Class<dynamic>> {
+}
+extension ExtensionOnS5 on self::G<self::ConcreteClass> {
+}
+extension ExtensionOnS6 on self::G<self::Class<self::ConcreteClass>> {
+}
+extension ExtensionOnS7 on self::G<core::Object> {
+}
+extension ExtensionOnS8 on self::G<core::int> {
+}
+static method main() → dynamic {}
+static method _#F#new#tearOff<X extends self::Class<self::_#F#new#tearOff::X> = self::Class<dynamic>>() → self::Class<self::_#F#new#tearOff::X>
+ return new self::Class::•<self::_#F#new#tearOff::X>();
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::EnumImplementsT1 {index:#C1, _name:#C2}
+ #C4 = <self::EnumImplementsT1*>[#C3]
+ #C5 = self::EnumImplementsT2 {index:#C1, _name:#C2}
+ #C6 = <self::EnumImplementsT2*>[#C5]
+ #C7 = self::EnumImplementsT3 {index:#C1, _name:#C2}
+ #C8 = <self::EnumImplementsT3*>[#C7]
+ #C9 = self::EnumImplementsT4 {index:#C1, _name:#C2}
+ #C10 = <self::EnumImplementsT4*>[#C9]
+ #C11 = self::EnumImplementsT5 {index:#C1, _name:#C2}
+ #C12 = <self::EnumImplementsT5*>[#C11]
+ #C13 = self::EnumImplementsT6 {index:#C1, _name:#C2}
+ #C14 = <self::EnumImplementsT6*>[#C13]
+ #C15 = self::EnumImplementsT7 {index:#C1, _name:#C2}
+ #C16 = <self::EnumImplementsT7*>[#C15]
+ #C17 = self::EnumImplementsT8 {index:#C1, _name:#C2}
+ #C18 = <self::EnumImplementsT8*>[#C17]
+ #C19 = self::EnumImplementsS1 {index:#C1, _name:#C2}
+ #C20 = <self::EnumImplementsS1*>[#C19]
+ #C21 = self::EnumImplementsS2 {index:#C1, _name:#C2}
+ #C22 = <self::EnumImplementsS2*>[#C21]
+ #C23 = self::EnumImplementsS3 {index:#C1, _name:#C2}
+ #C24 = <self::EnumImplementsS3*>[#C23]
+ #C25 = self::EnumImplementsS4 {index:#C1, _name:#C2}
+ #C26 = <self::EnumImplementsS4*>[#C25]
+ #C27 = self::EnumImplementsS5 {index:#C1, _name:#C2}
+ #C28 = <self::EnumImplementsS5*>[#C27]
+ #C29 = self::EnumImplementsS6 {index:#C1, _name:#C2}
+ #C30 = <self::EnumImplementsS6*>[#C29]
+ #C31 = self::EnumImplementsS7 {index:#C1, _name:#C2}
+ #C32 = <self::EnumImplementsS7*>[#C31]
+ #C33 = self::EnumImplementsS8 {index:#C1, _name:#C2}
+ #C34 = <self::EnumImplementsS8*>[#C33]
+ #C35 = self::EnumWithT1 {index:#C1, _name:#C2}
+ #C36 = <self::EnumWithT1*>[#C35]
+ #C37 = self::EnumWithT2 {index:#C1, _name:#C2}
+ #C38 = <self::EnumWithT2*>[#C37]
+ #C39 = self::EnumWithT3 {index:#C1, _name:#C2}
+ #C40 = <self::EnumWithT3*>[#C39]
+ #C41 = self::EnumWithT4 {index:#C1, _name:#C2}
+ #C42 = <self::EnumWithT4*>[#C41]
+ #C43 = self::EnumWithT5 {index:#C1, _name:#C2}
+ #C44 = <self::EnumWithT5*>[#C43]
+ #C45 = self::EnumWithT6 {index:#C1, _name:#C2}
+ #C46 = <self::EnumWithT6*>[#C45]
+ #C47 = self::EnumWithT7 {index:#C1, _name:#C2}
+ #C48 = <self::EnumWithT7*>[#C47]
+ #C49 = self::EnumWithT8 {index:#C1, _name:#C2}
+ #C50 = <self::EnumWithT8*>[#C49]
+ #C51 = self::EnumWithS1 {index:#C1, _name:#C2}
+ #C52 = <self::EnumWithS1*>[#C51]
+ #C53 = self::EnumWithS2 {index:#C1, _name:#C2}
+ #C54 = <self::EnumWithS2*>[#C53]
+ #C55 = self::EnumWithS3 {index:#C1, _name:#C2}
+ #C56 = <self::EnumWithS3*>[#C55]
+ #C57 = self::EnumWithS4 {index:#C1, _name:#C2}
+ #C58 = <self::EnumWithS4*>[#C57]
+ #C59 = self::EnumWithS5 {index:#C1, _name:#C2}
+ #C60 = <self::EnumWithS5*>[#C59]
+ #C61 = self::EnumWithS6 {index:#C1, _name:#C2}
+ #C62 = <self::EnumWithS6*>[#C61]
+ #C63 = self::EnumWithS7 {index:#C1, _name:#C2}
+ #C64 = <self::EnumWithS7*>[#C63]
+ #C65 = self::EnumWithS8 {index:#C1, _name:#C2}
+ #C66 = <self::EnumWithS8*>[#C65]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_supertypes.dart:
+- EnumImplementsT1. (from org-dartlang-testcase:///bounds_supertypes.dart:109:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- EnumImplementsT2. (from org-dartlang-testcase:///bounds_supertypes.dart:111:6)
+- EnumImplementsT3. (from org-dartlang-testcase:///bounds_supertypes.dart:113:6)
+- EnumImplementsT4. (from org-dartlang-testcase:///bounds_supertypes.dart:115:6)
+- EnumImplementsT5. (from org-dartlang-testcase:///bounds_supertypes.dart:117:6)
+- EnumImplementsT6. (from org-dartlang-testcase:///bounds_supertypes.dart:119:6)
+- EnumImplementsT7. (from org-dartlang-testcase:///bounds_supertypes.dart:121:6)
+- EnumImplementsT8. (from org-dartlang-testcase:///bounds_supertypes.dart:123:6)
+- EnumImplementsS1. (from org-dartlang-testcase:///bounds_supertypes.dart:125:6)
+- EnumImplementsS2. (from org-dartlang-testcase:///bounds_supertypes.dart:127:6)
+- EnumImplementsS3. (from org-dartlang-testcase:///bounds_supertypes.dart:129:6)
+- EnumImplementsS4. (from org-dartlang-testcase:///bounds_supertypes.dart:131:6)
+- EnumImplementsS5. (from org-dartlang-testcase:///bounds_supertypes.dart:133:6)
+- EnumImplementsS6. (from org-dartlang-testcase:///bounds_supertypes.dart:135:6)
+- EnumImplementsS7. (from org-dartlang-testcase:///bounds_supertypes.dart:137:6)
+- EnumImplementsS8. (from org-dartlang-testcase:///bounds_supertypes.dart:139:6)
+- EnumWithT1. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- _EnumWithT1&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:141:6)
+- EnumWithT2. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- _EnumWithT2&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:143:6)
+- EnumWithT3. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- _EnumWithT3&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:145:6)
+- EnumWithT4. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- _EnumWithT4&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:147:6)
+- EnumWithT5. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- _EnumWithT5&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:149:6)
+- EnumWithT6. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- _EnumWithT6&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:151:6)
+- EnumWithT7. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- _EnumWithT7&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:153:6)
+- EnumWithT8. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- _EnumWithT8&_Enum&F. (from org-dartlang-testcase:///bounds_supertypes.dart:155:6)
+- EnumWithS1. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- _EnumWithS1&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:157:6)
+- EnumWithS2. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- _EnumWithS2&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:159:6)
+- EnumWithS3. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- _EnumWithS3&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:161:6)
+- EnumWithS4. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- _EnumWithS4&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:163:6)
+- EnumWithS5. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- _EnumWithS5&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:165:6)
+- EnumWithS6. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- _EnumWithS6&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:167:6)
+- EnumWithS7. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- _EnumWithS7&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:169:6)
+- EnumWithS8. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
+- _EnumWithS8&_Enum&G. (from org-dartlang-testcase:///bounds_supertypes.dart:171:6)
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart b/pkg/front_end/testcases/general/bounds_type_aliases.dart
new file mode 100644
index 0000000..001c960
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart
@@ -0,0 +1,50 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef T1 = F; // Error
+typedef T2 = F<dynamic>; // Error
+typedef T3 = F<Class>; // Error
+typedef T4 = F<Class<dynamic>>; // Error
+typedef T5 = F<ConcreteClass>; // Ok
+typedef T6 = F<Class<ConcreteClass>>; // Ok
+typedef T7 = F<Object>; // Error
+typedef T8 = F<int>; // Error
+
+typedef S1 = G; // Error
+typedef S2 = G<dynamic>; // Error
+typedef S3 = G<Class>; // Error
+typedef S4 = G<Class<dynamic>>; // Error
+typedef S5 = G<ConcreteClass>; // Ok
+typedef S6 = G<Class<ConcreteClass>>; // Ok
+typedef S7 = G<Object>; // Error
+typedef S8 = G<int>; // Error
+
+typedef Typedef1 = void Function<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >();
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline.expect
new file mode 100644
index 0000000..1de49ae
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline.expect
@@ -0,0 +1,42 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef T1 = F;
+typedef T2 = F<dynamic>;
+typedef T3 = F<Class>;
+typedef T4 = F<Class<dynamic>>;
+typedef T5 = F<ConcreteClass>;
+typedef T6 = F<Class<ConcreteClass>>;
+typedef T7 = F<Object>;
+typedef T8 = F<int>;
+typedef S1 = G;
+typedef S2 = G<dynamic>;
+typedef S3 = G<Class>;
+typedef S4 = G<Class<dynamic>>;
+typedef S5 = G<ConcreteClass>;
+typedef S6 = G<Class<ConcreteClass>>;
+typedef S7 = G<Object>;
+typedef S8 = G<int>;
+typedef Typedef1 = void Function<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..c61e199
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.textual_outline_modelled.expect
@@ -0,0 +1,41 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+typedef F<X extends Class<X>> = X;
+typedef S1 = G;
+typedef S2 = G<dynamic>;
+typedef S3 = G<Class>;
+typedef S4 = G<Class<dynamic>>;
+typedef S5 = G<ConcreteClass>;
+typedef S6 = G<Class<ConcreteClass>>;
+typedef S7 = G<Object>;
+typedef S8 = G<int>;
+typedef T1 = F;
+typedef T2 = F<dynamic>;
+typedef T3 = F<Class>;
+typedef T4 = F<Class<dynamic>>;
+typedef T5 = F<ConcreteClass>;
+typedef T6 = F<Class<ConcreteClass>>;
+typedef T7 = F<Object>;
+typedef T8 = F<int>;
+typedef Typedef1 = void Function<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.expect
new file mode 100644
index 0000000..bc261f0
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.expect
@@ -0,0 +1,205 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:32:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:40:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:38:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:39:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:46:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:47:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:13:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef T1 = F; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:14:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T2 = F<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:15:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T3 = F<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:16:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T4 = F<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:19:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T7 = F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:20:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T8 = F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:22:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef S1 = G; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:23:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S2 = G<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:24:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S3 = G<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:25:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S4 = G<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:28:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S7 = G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:29:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S8 = G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef T1 = self::Class<dynamic>;
+typedef T2 = dynamic;
+typedef T3 = self::Class<dynamic>;
+typedef T4 = self::Class<dynamic>;
+typedef T5 = self::ConcreteClass;
+typedef T6 = self::Class<self::ConcreteClass>;
+typedef T7 = core::Object;
+typedef T8 = core::int;
+typedef S1 = self::G<self::Class<dynamic>>;
+typedef S2 = self::G<dynamic>;
+typedef S3 = self::G<self::Class<dynamic>>;
+typedef S4 = self::G<self::Class<dynamic>>;
+typedef S5 = self::G<self::ConcreteClass>;
+typedef S6 = self::G<self::Class<self::ConcreteClass>>;
+typedef S7 = self::G<core::Object>;
+typedef S8 = self::G<core::int>;
+typedef Typedef1 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.modular.expect
new file mode 100644
index 0000000..bc261f0
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.modular.expect
@@ -0,0 +1,205 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:32:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:40:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:38:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:39:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:46:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:47:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:13:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef T1 = F; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:14:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T2 = F<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:15:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T3 = F<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:16:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T4 = F<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:19:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T7 = F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:20:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T8 = F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:22:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef S1 = G; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:23:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S2 = G<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:24:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S3 = G<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:25:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S4 = G<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:28:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S7 = G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:29:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S8 = G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef T1 = self::Class<dynamic>;
+typedef T2 = dynamic;
+typedef T3 = self::Class<dynamic>;
+typedef T4 = self::Class<dynamic>;
+typedef T5 = self::ConcreteClass;
+typedef T6 = self::Class<self::ConcreteClass>;
+typedef T7 = core::Object;
+typedef T8 = core::int;
+typedef S1 = self::G<self::Class<dynamic>>;
+typedef S2 = self::G<dynamic>;
+typedef S3 = self::G<self::Class<dynamic>>;
+typedef S4 = self::G<self::Class<dynamic>>;
+typedef S5 = self::G<self::ConcreteClass>;
+typedef S6 = self::G<self::Class<self::ConcreteClass>>;
+typedef S7 = self::G<core::Object>;
+typedef S8 = self::G<core::int>;
+typedef Typedef1 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.outline.expect
new file mode 100644
index 0000000..0326770
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.outline.expect
@@ -0,0 +1,203 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:32:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:40:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:38:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:39:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:46:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:47:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:13:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef T1 = F; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:14:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T2 = F<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:15:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T3 = F<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:16:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T4 = F<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:19:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T7 = F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:20:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T8 = F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:22:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef S1 = G; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:23:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S2 = G<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:24:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S3 = G<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:25:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S4 = G<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:28:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S7 = G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:29:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S8 = G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef T1 = self::Class<dynamic>;
+typedef T2 = dynamic;
+typedef T3 = self::Class<dynamic>;
+typedef T4 = self::Class<dynamic>;
+typedef T5 = self::ConcreteClass;
+typedef T6 = self::Class<self::ConcreteClass>;
+typedef T7 = core::Object;
+typedef T8 = core::int;
+typedef S1 = self::G<self::Class<dynamic>>;
+typedef S2 = self::G<dynamic>;
+typedef S3 = self::G<self::Class<dynamic>>;
+typedef S4 = self::G<self::Class<dynamic>>;
+typedef S5 = self::G<self::ConcreteClass>;
+typedef S6 = self::G<self::Class<self::ConcreteClass>>;
+typedef S7 = self::G<core::Object>;
+typedef S8 = self::G<core::int>;
+typedef Typedef1 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.transformed.expect
new file mode 100644
index 0000000..bc261f0
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_aliases.dart.weak.transformed.expect
@@ -0,0 +1,205 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:32:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:40:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:38:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:39:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:46:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:47:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:13:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef T1 = F; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:14:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T2 = F<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:15:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T3 = F<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:16:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T4 = F<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:19:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T7 = F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:20:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef T8 = F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:22:14: Error: Inferred type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// typedef S1 = G; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:23:14: Error: Type argument 'dynamic' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S2 = G<dynamic>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:24:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S3 = G<Class>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:25:14: Error: Type argument 'Class<dynamic>' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S4 = G<Class<dynamic>>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:28:14: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S7 = G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:29:14: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_aliases.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// typedef S8 = G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_aliases.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef T1 = self::Class<dynamic>;
+typedef T2 = dynamic;
+typedef T3 = self::Class<dynamic>;
+typedef T4 = self::Class<dynamic>;
+typedef T5 = self::ConcreteClass;
+typedef T6 = self::Class<self::ConcreteClass>;
+typedef T7 = core::Object;
+typedef T8 = core::int;
+typedef S1 = self::G<self::Class<dynamic>>;
+typedef S2 = self::G<dynamic>;
+typedef S3 = self::G<self::Class<dynamic>>;
+typedef S4 = self::G<self::Class<dynamic>>;
+typedef S5 = self::G<self::ConcreteClass>;
+typedef S6 = self::G<self::Class<self::ConcreteClass>>;
+typedef S7 = self::G<core::Object>;
+typedef S8 = self::G<core::int>;
+typedef Typedef1 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart b/pkg/front_end/testcases/general/bounds_type_arguments.dart
new file mode 100644
index 0000000..47fd340
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart
@@ -0,0 +1,204 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef H<X> = Class2;
+
+void staticMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7,
+ S8>() {}
+
+class Class1<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7, S8> {
+ Class1();
+
+ factory Class1.fact() => new Class1();
+
+ factory Class1.redirect() = Class1;
+}
+
+class Class2 {
+ void instanceMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6,
+ S7, S8>() {}
+}
+
+test() {
+ staticMethod<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >();
+
+ var tearOff = staticMethod;
+ tearOff<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >();
+
+ tearOff<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >;
+
+ new Class1<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >();
+
+ new Class1<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >.fact();
+
+ new Class1<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >.redirect();
+
+ new Class2().instanceMethod<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >();
+
+ dynamic d = staticMethod;
+ d<
+ F, // Ok
+ F<dynamic>, // Ok
+ F<Class>, // Ok
+ F<Class<dynamic>>, // Ok
+ F<ConcreteClass>, // Ok
+ F<Class<ConcreteClass>>, // Ok
+ F<Object>, // Error
+ F<int>, // Error
+ G, // Ok
+ G<dynamic>, // Ok
+ G<Class>, // Ok
+ G<Class<dynamic>>, // Ok
+ G<ConcreteClass>, // Ok
+ G<Class<ConcreteClass>>, // Ok
+ G<Object>, // Error
+ G<int> // Error
+ >();
+
+ new H<F>(); // Ok
+ new H<F<dynamic>>(); // Ok
+ new H<F<Class>>(); // Ok
+ new H<F<Class<dynamic>>>(); // Ok
+ new H<F<ConcreteClass>>(); // Ok
+ new H<F<Class<ConcreteClass>>>(); // Ok
+ new H<F<Object>>(); // Error
+ new H<F<int>>(); // Error
+ new H<G>(); // Ok
+ new H<G<dynamic>>(); // Ok
+ new H<G<Class>>(); // Ok
+ new H<G<Class<dynamic>>>(); // Ok
+ new H<G<ConcreteClass>>(); // Ok
+ new H<G<Class<ConcreteClass>>>(); // Ok
+ new H<G<Object>>(); // Error
+ new H<G<int>>(); // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline.expect
new file mode 100644
index 0000000..62264e3
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline.expect
@@ -0,0 +1,25 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef H<X> = Class2;
+void staticMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7,
+ S8>() {}
+
+class Class1<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7, S8> {
+ Class1();
+ factory Class1.fact() => new Class1();
+ factory Class1.redirect() = Class1;
+}
+
+class Class2 {
+ void instanceMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6,
+ S7, S8>() {}
+}
+
+test() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..31c481b
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.textual_outline_modelled.expect
@@ -0,0 +1,23 @@
+class Class<T> {}
+
+class Class1<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7, S8> {
+ Class1();
+ factory Class1.fact() => new Class1();
+ factory Class1.redirect() = Class1;
+}
+
+class Class2 {
+ void instanceMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6,
+ S7, S8>() {}
+}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+test() {}
+typedef F<X extends Class<X>> = X;
+typedef H<X> = Class2;
+void staticMethod<T1, T2, T3, T4, T5, T6, T7, T8, S1, S2, S3, S4, S5, S6, S7,
+ S8>() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.expect
new file mode 100644
index 0000000..4d4b0ad
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.expect
@@ -0,0 +1,419 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:39:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:40:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:47:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:48:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:59:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:60:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:67:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:68:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:78:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:79:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:86:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:87:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:97:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:98:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:105:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:106:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:116:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:117:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:124:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:125:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:135:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:136:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:143:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:144:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:154:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:155:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:162:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:163:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:174:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:175:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:182:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:183:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:192:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:193:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:200:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:201:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef H<unrelated X extends core::Object? = dynamic> = self::Class2;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic> extends core::Object {
+ static final field dynamic _redirecting# = <dynamic>[#C1]/*isLegacy*/;
+ constructor •() → self::Class1<self::Class1::T1%, self::Class1::T2%, self::Class1::T3%, self::Class1::T4%, self::Class1::T5%, self::Class1::T6%, self::Class1::T7%, self::Class1::T8%, self::Class1::S1%, self::Class1::S2%, self::Class1::S3%, self::Class1::S4%, self::Class1::S5%, self::Class1::S6%, self::Class1::S7%, self::Class1::S8%>
+ : super core::Object::•()
+ ;
+ static factory fact<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>
+ return new self::Class1::•<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>();
+ static factory redirect<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>
+ return new self::Class1::•<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>();
+}
+class Class2 extends core::Object {
+ synthetic constructor •() → self::Class2
+ : super core::Object::•()
+ ;
+ method instanceMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+}
+static method staticMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+static method test() → dynamic {
+ self::staticMethod<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ <T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void tearOff = #C2;
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>;
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ self::Class1::fact<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•().{self::Class2::instanceMethod}<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ dynamic d = #C2;
+ d{dynamic}.call<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+}
+static method main() → dynamic {}
+static method _#H#new#tearOff<unrelated X extends core::Object? = dynamic>() → self::Class2
+ return new self::Class2::•();
+
+constants {
+ #C1 = constructor-tearoff self::Class1::redirect
+ #C2 = static-tearoff self::staticMethod
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.modular.expect
new file mode 100644
index 0000000..4d4b0ad
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.modular.expect
@@ -0,0 +1,419 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:39:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:40:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:47:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:48:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:59:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:60:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:67:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:68:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:78:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:79:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:86:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:87:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:97:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:98:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:105:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:106:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:116:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:117:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:124:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:125:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:135:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:136:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:143:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:144:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:154:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:155:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:162:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:163:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:174:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:175:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:182:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:183:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:192:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:193:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:200:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:201:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef H<unrelated X extends core::Object? = dynamic> = self::Class2;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic> extends core::Object {
+ static final field dynamic _redirecting# = <dynamic>[#C1]/*isLegacy*/;
+ constructor •() → self::Class1<self::Class1::T1%, self::Class1::T2%, self::Class1::T3%, self::Class1::T4%, self::Class1::T5%, self::Class1::T6%, self::Class1::T7%, self::Class1::T8%, self::Class1::S1%, self::Class1::S2%, self::Class1::S3%, self::Class1::S4%, self::Class1::S5%, self::Class1::S6%, self::Class1::S7%, self::Class1::S8%>
+ : super core::Object::•()
+ ;
+ static factory fact<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>
+ return new self::Class1::•<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>();
+ static factory redirect<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>
+ return new self::Class1::•<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>();
+}
+class Class2 extends core::Object {
+ synthetic constructor •() → self::Class2
+ : super core::Object::•()
+ ;
+ method instanceMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+}
+static method staticMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+static method test() → dynamic {
+ self::staticMethod<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ <T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void tearOff = #C2;
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>;
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ self::Class1::fact<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•().{self::Class2::instanceMethod}<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ dynamic d = #C2;
+ d{dynamic}.call<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+}
+static method main() → dynamic {}
+static method _#H#new#tearOff<unrelated X extends core::Object? = dynamic>() → self::Class2
+ return new self::Class2::•();
+
+constants {
+ #C1 = constructor-tearoff self::Class1::redirect
+ #C2 = static-tearoff self::staticMethod
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.outline.expect
new file mode 100644
index 0000000..a7a3717
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.outline.expect
@@ -0,0 +1,46 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef H<unrelated X extends core::Object? = dynamic> = self::Class2;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic> extends core::Object {
+ static final field dynamic _redirecting# = <dynamic>[self::Class1::redirect]/*isLegacy*/;
+ constructor •() → self::Class1<self::Class1::T1%, self::Class1::T2%, self::Class1::T3%, self::Class1::T4%, self::Class1::T5%, self::Class1::T6%, self::Class1::T7%, self::Class1::T8%, self::Class1::S1%, self::Class1::S2%, self::Class1::S3%, self::Class1::S4%, self::Class1::S5%, self::Class1::S6%, self::Class1::S7%, self::Class1::S8%>
+ ;
+ static factory fact<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>
+ ;
+ static factory redirect<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>
+ return new self::Class1::•<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>();
+}
+class Class2 extends core::Object {
+ synthetic constructor •() → self::Class2
+ ;
+ method instanceMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void
+ ;
+}
+static method staticMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void
+ ;
+static method test() → dynamic
+ ;
+static method main() → dynamic
+ ;
+static method _#H#new#tearOff<unrelated X extends core::Object? = dynamic>() → self::Class2
+ return new self::Class2::•();
+
+
+Extra constant evaluation status:
+Evaluated: ConstructorTearOff @ org-dartlang-testcase:///bounds_type_arguments.dart:18:7 -> ConstructorTearOffConstant(Class1.redirect)
+Extra constant evaluation: evaluated: 4, effectively constant: 1
diff --git a/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.transformed.expect
new file mode 100644
index 0000000..4d4b0ad
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_arguments.dart.weak.transformed.expect
@@ -0,0 +1,419 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:39:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:40:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:47:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:48:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:59:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:60:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:67:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:68:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:78:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:79:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:86:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:87:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:97:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:98:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:105:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:106:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:116:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:117:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:124:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:125:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:135:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:136:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:143:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:144:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:154:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:155:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:162:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:163:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:174:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:175:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:182:7: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:183:7: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:192:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:193:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<F<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:200:9: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<Object>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:201:9: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_arguments.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// new H<G<int>>(); // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_arguments.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef H<unrelated X extends core::Object? = dynamic> = self::Class2;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic> extends core::Object {
+ static final field dynamic _redirecting# = <dynamic>[#C1]/*isLegacy*/;
+ constructor •() → self::Class1<self::Class1::T1%, self::Class1::T2%, self::Class1::T3%, self::Class1::T4%, self::Class1::T5%, self::Class1::T6%, self::Class1::T7%, self::Class1::T8%, self::Class1::S1%, self::Class1::S2%, self::Class1::S3%, self::Class1::S4%, self::Class1::S5%, self::Class1::S6%, self::Class1::S7%, self::Class1::S8%>
+ : super core::Object::•()
+ ;
+ static factory fact<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>
+ return new self::Class1::•<self::Class1::fact::T1%, self::Class1::fact::T2%, self::Class1::fact::T3%, self::Class1::fact::T4%, self::Class1::fact::T5%, self::Class1::fact::T6%, self::Class1::fact::T7%, self::Class1::fact::T8%, self::Class1::fact::S1%, self::Class1::fact::S2%, self::Class1::fact::S3%, self::Class1::fact::S4%, self::Class1::fact::S5%, self::Class1::fact::S6%, self::Class1::fact::S7%, self::Class1::fact::S8%>();
+ static factory redirect<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → self::Class1<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>
+ return new self::Class1::•<self::Class1::redirect::T1%, self::Class1::redirect::T2%, self::Class1::redirect::T3%, self::Class1::redirect::T4%, self::Class1::redirect::T5%, self::Class1::redirect::T6%, self::Class1::redirect::T7%, self::Class1::redirect::T8%, self::Class1::redirect::S1%, self::Class1::redirect::S2%, self::Class1::redirect::S3%, self::Class1::redirect::S4%, self::Class1::redirect::S5%, self::Class1::redirect::S6%, self::Class1::redirect::S7%, self::Class1::redirect::S8%>();
+}
+class Class2 extends core::Object {
+ synthetic constructor •() → self::Class2
+ : super core::Object::•()
+ ;
+ method instanceMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+}
+static method staticMethod<T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void {}
+static method test() → dynamic {
+ self::staticMethod<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ <T1 extends core::Object? = dynamic, T2 extends core::Object? = dynamic, T3 extends core::Object? = dynamic, T4 extends core::Object? = dynamic, T5 extends core::Object? = dynamic, T6 extends core::Object? = dynamic, T7 extends core::Object? = dynamic, T8 extends core::Object? = dynamic, S1 extends core::Object? = dynamic, S2 extends core::Object? = dynamic, S3 extends core::Object? = dynamic, S4 extends core::Object? = dynamic, S5 extends core::Object? = dynamic, S6 extends core::Object? = dynamic, S7 extends core::Object? = dynamic, S8 extends core::Object? = dynamic>() → void tearOff = #C2;
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ tearOff<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>;
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ self::Class1::fact<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class1::•<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•().{self::Class2::instanceMethod}<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>(){() → void};
+ dynamic d = #C2;
+ d{dynamic}.call<self::Class<dynamic>, dynamic, self::Class<dynamic>, self::Class<dynamic>, self::ConcreteClass, self::Class<self::ConcreteClass>, core::Object, core::int, self::G<self::Class<dynamic>>, self::G<dynamic>, self::G<self::Class<dynamic>>, self::G<self::Class<dynamic>>, self::G<self::ConcreteClass>, self::G<self::Class<self::ConcreteClass>>, self::G<core::Object>, self::G<core::int>>();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+ new self::Class2::•();
+}
+static method main() → dynamic {}
+static method _#H#new#tearOff<unrelated X extends core::Object? = dynamic>() → self::Class2
+ return new self::Class2::•();
+
+constants {
+ #C1 = constructor-tearoff self::Class1::redirect
+ #C2 = static-tearoff self::staticMethod
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart b/pkg/front_end/testcases/general/bounds_type_literals.dart
new file mode 100644
index 0000000..2c4f20a
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart
@@ -0,0 +1,34 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+class Class1 {}
+
+test() {
+ F; // Ok
+ F<dynamic>; // Ok
+ F<Class>; // Ok
+ F<Class<dynamic>>; // Ok
+ F<ConcreteClass>; // Ok
+ F<Class<ConcreteClass>>; // Ok
+ F<Object>; // Error
+ F<int>; // Error
+ G; // Ok
+ G<dynamic>; // Ok
+ G<Class>; // Ok
+ G<Class<dynamic>>; // Ok
+ G<ConcreteClass>; // Ok
+ G<Class<ConcreteClass>>; // Ok
+ G<Object>; // Error
+ G<int>; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline.expect
new file mode 100644
index 0000000..d7e1cd1
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline.expect
@@ -0,0 +1,12 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+class Class1 {}
+
+test() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..105a3bd
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.textual_outline_modelled.expect
@@ -0,0 +1,11 @@
+class Class<T> {}
+
+class Class1 {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+test() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.expect
new file mode 100644
index 0000000..1f414e9
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.expect
@@ -0,0 +1,100 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:22:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:23:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:30:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:31:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ #C1;
+ #C2;
+ #C1;
+ #C1;
+ #C3;
+ #C4;
+ #C5;
+ #C6;
+ #C7;
+ #C8;
+ #C7;
+ #C7;
+ #C9;
+ #C10;
+ #C11;
+ #C12;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = TypeLiteralConstant(self::Class<dynamic>*)
+ #C2 = TypeLiteralConstant(dynamic)
+ #C3 = TypeLiteralConstant(self::ConcreteClass*)
+ #C4 = TypeLiteralConstant(self::Class<self::ConcreteClass*>*)
+ #C5 = TypeLiteralConstant(core::Object*)
+ #C6 = TypeLiteralConstant(core::int*)
+ #C7 = TypeLiteralConstant(self::G<self::Class<dynamic>*>*)
+ #C8 = TypeLiteralConstant(self::G<dynamic>*)
+ #C9 = TypeLiteralConstant(self::G<self::ConcreteClass*>*)
+ #C10 = TypeLiteralConstant(self::G<self::Class<self::ConcreteClass*>*>*)
+ #C11 = TypeLiteralConstant(self::G<core::Object*>*)
+ #C12 = TypeLiteralConstant(self::G<core::int*>*)
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.modular.expect
new file mode 100644
index 0000000..1f414e9
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.modular.expect
@@ -0,0 +1,100 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:22:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:23:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:30:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:31:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ #C1;
+ #C2;
+ #C1;
+ #C1;
+ #C3;
+ #C4;
+ #C5;
+ #C6;
+ #C7;
+ #C8;
+ #C7;
+ #C7;
+ #C9;
+ #C10;
+ #C11;
+ #C12;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = TypeLiteralConstant(self::Class<dynamic>*)
+ #C2 = TypeLiteralConstant(dynamic)
+ #C3 = TypeLiteralConstant(self::ConcreteClass*)
+ #C4 = TypeLiteralConstant(self::Class<self::ConcreteClass*>*)
+ #C5 = TypeLiteralConstant(core::Object*)
+ #C6 = TypeLiteralConstant(core::int*)
+ #C7 = TypeLiteralConstant(self::G<self::Class<dynamic>*>*)
+ #C8 = TypeLiteralConstant(self::G<dynamic>*)
+ #C9 = TypeLiteralConstant(self::G<self::ConcreteClass*>*)
+ #C10 = TypeLiteralConstant(self::G<self::Class<self::ConcreteClass*>*>*)
+ #C11 = TypeLiteralConstant(self::G<core::Object*>*)
+ #C12 = TypeLiteralConstant(self::G<core::int*>*)
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.outline.expect
new file mode 100644
index 0000000..354780e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.outline.expect
@@ -0,0 +1,25 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ ;
+}
+static method test() → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.transformed.expect
new file mode 100644
index 0000000..1f414e9
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_literals.dart.weak.transformed.expect
@@ -0,0 +1,100 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:22:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:23:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:30:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_literals.dart:31:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_literals.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int>; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_literals.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1 extends core::Object {
+ synthetic constructor •() → self::Class1
+ : super core::Object::•()
+ ;
+}
+static method test() → dynamic {
+ #C1;
+ #C2;
+ #C1;
+ #C1;
+ #C3;
+ #C4;
+ #C5;
+ #C6;
+ #C7;
+ #C8;
+ #C7;
+ #C7;
+ #C9;
+ #C10;
+ #C11;
+ #C12;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = TypeLiteralConstant(self::Class<dynamic>*)
+ #C2 = TypeLiteralConstant(dynamic)
+ #C3 = TypeLiteralConstant(self::ConcreteClass*)
+ #C4 = TypeLiteralConstant(self::Class<self::ConcreteClass*>*)
+ #C5 = TypeLiteralConstant(core::Object*)
+ #C6 = TypeLiteralConstant(core::int*)
+ #C7 = TypeLiteralConstant(self::G<self::Class<dynamic>*>*)
+ #C8 = TypeLiteralConstant(self::G<dynamic>*)
+ #C9 = TypeLiteralConstant(self::G<self::ConcreteClass*>*)
+ #C10 = TypeLiteralConstant(self::G<self::Class<self::ConcreteClass*>*>*)
+ #C11 = TypeLiteralConstant(self::G<core::Object*>*)
+ #C12 = TypeLiteralConstant(self::G<core::int*>*)
+}
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart b/pkg/front_end/testcases/general/bounds_type_parameters.dart
new file mode 100644
index 0000000..3a1e8eb
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart
@@ -0,0 +1,243 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef Typedef1<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >
+ = void Function();
+
+typedef Typedef2 = void Function<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >();
+
+typedef void Typedef3<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >();
+
+class Class1<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ > {}
+
+class Class2<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ > = Object with Class;
+
+mixin Mixin1<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ > {}
+
+// TODO(johnniwinther): Check/create this type as regular bounded i2b.
+enum Enum1<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Error
+ T4 extends F<Class<dynamic>>, // Error
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Error
+ S3 extends G<Class>, // Error
+ S4 extends G<Class<dynamic>>, // Error
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ > {
+ a<
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>>()
+}
+
+extension Extension<
+ T1 extends F, // Ok
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Ok
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ > on Class {}
+
+void method1<
+ T1 extends F, // Error
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Error
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >() {}
+
+test() {
+ void local1<
+ T1 extends F, // Ok
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Ok
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >() {}
+ void Function<
+ T1 extends F, // Ok
+ T2 extends F<dynamic>, // Ok
+ T3 extends F<Class>, // Ok
+ T4 extends F<Class<dynamic>>, // Ok
+ T5 extends F<ConcreteClass>, // Ok
+ T6 extends F<Class<ConcreteClass>>, // Ok
+ T7 extends F<Object>, // Error
+ T8 extends F<int>, // Error
+ S1 extends G, // Ok
+ S2 extends G<dynamic>, // Ok
+ S3 extends G<Class>, // Ok
+ S4 extends G<Class<dynamic>>, // Ok
+ S5 extends G<ConcreteClass>, // Ok
+ S6 extends G<Class<ConcreteClass>>, // Ok
+ S7 extends G<Object>, // Error
+ S8 extends G<int> // Error
+ >() local;
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline.expect
new file mode 100644
index 0000000..7608f2d
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline.expect
@@ -0,0 +1,187 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+typedef Typedef1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>
+ = void Function();
+typedef Typedef2 = void Function<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
+typedef void Typedef3<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
+
+class Class1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {}
+
+class Class2<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> = Object with Class;
+mixin Mixin1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {}
+
+enum Enum1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {
+ a<
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>>()
+}
+
+extension Extension<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> on Class {}
+
+void method1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>() {}
+test() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..216f660
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.textual_outline_modelled.expect
@@ -0,0 +1,185 @@
+class Class<T> {}
+
+class Class1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {}
+
+class Class2<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> = Object with Class;
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+enum Enum1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {
+ a<
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ ConcreteClass,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>,
+ G<ConcreteClass>>()
+}
+
+extension Extension<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> on Class {}
+
+main() {}
+mixin Mixin1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>> {}
+test() {}
+typedef F<X extends Class<X>> = X;
+typedef Typedef1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>
+ = void Function();
+typedef Typedef2 = void Function<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
+typedef void Typedef3<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>();
+void method1<
+ T1 extends F,
+ T2 extends F<dynamic>,
+ T3 extends F<Class>,
+ T4 extends F<Class<dynamic>>,
+ T5 extends F<ConcreteClass>,
+ T6 extends F<Class<ConcreteClass>>,
+ T7 extends F<Object>,
+ T8 extends F<int>,
+ S1 extends G,
+ S2 extends G<dynamic>,
+ S3 extends G<Class>,
+ S4 extends G<Class<dynamic>>,
+ S5 extends G<ConcreteClass>,
+ S6 extends G<Class<ConcreteClass>>,
+ S7 extends G<Object>,
+ S8 extends G<int>>() {}
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.expect
new file mode 100644
index 0000000..dbd7faa
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.expect
@@ -0,0 +1,634 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:14:9: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:22:9: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:34:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:42:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:53:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:61:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:72:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:80:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:91:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:99:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:110:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:118:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:130:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:138:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:186:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:194:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:20:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:21:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:28:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:29:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:40:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:41:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:48:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:49:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:59:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:60:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:67:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:68:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:78:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:79:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:86:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:87:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:97:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:98:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:105:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:106:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:116:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:117:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:124:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:125:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:136:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:144:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:173:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:174:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:181:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:182:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:192:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:193:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:200:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:201:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'ConcreteClass' doesn't conform to the bound 'int' of the type variable 'T8' on 'Enum1'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:5: Context: This is the type variable whose bound isn't conformed to.
+// T8 extends F<int>, // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'G<ConcreteClass>' doesn't conform to the bound 'G<int>' of the type variable 'S8' on 'Enum1'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:5: Context: This is the type variable whose bound isn't conformed to.
+// S8 extends G<int> // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:212:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:213:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:220:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:221:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:230:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:231:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:238:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:239:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef Typedef1<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+typedef Typedef2 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+typedef Typedef3<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class1<self::Class1::T1, self::Class1::T2%, self::Class1::T3, self::Class1::T4, self::Class1::T5, self::Class1::T6, self::Class1::T7, self::Class1::T8, self::Class1::S1, self::Class1::S2, self::Class1::S3, self::Class1::S4, self::Class1::S5, self::Class1::S6, self::Class1::S7, self::Class1::S8>
+ : super core::Object::•()
+ ;
+}
+class Class2<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> = core::Object with self::Class<dynamic> /*hasConstConstructor*/ {
+ const synthetic constructor •() → self::Class2<self::Class2::T1, self::Class2::T2%, self::Class2::T3, self::Class2::T4, self::Class2::T5, self::Class2::T6, self::Class2::T7, self::Class2::T8, self::Class2::S1, self::Class2::S2, self::Class2::S3, self::Class2::S4, self::Class2::S5, self::Class2::S6, self::Class2::S7, self::Class2::S8>
+ : super core::Object::•()
+ ;
+}
+abstract class Mixin1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object /*isMixinDeclaration*/ {
+}
+class Enum1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>> values = #C4;
+ static const field self::Enum1<self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>> a = #C3;
+ const constructor •(core::int index, core::String name) → self::Enum1<self::Enum1::T1, self::Enum1::T2%, self::Enum1::T3, self::Enum1::T4, self::Enum1::T5, self::Enum1::T6, self::Enum1::T7, self::Enum1::T8, self::Enum1::S1, self::Enum1::S2, self::Enum1::S3, self::Enum1::S4, self::Enum1::S5, self::Enum1::S6, self::Enum1::S7, self::Enum1::S8>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "Enum1.${this.{core::_Enum::_name}{core::String}}";
+}
+extension Extension<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>> on self::Class<dynamic> {
+}
+static method method1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void {}
+static method test() → dynamic {
+ function local1<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void {}
+ <T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void local;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::Enum1<self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*> {index:#C1, _name:#C2}
+ #C4 = <self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_type_parameters.dart:
+- Enum1. (from org-dartlang-testcase:///bounds_type_parameters.dart:129:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.modular.expect
new file mode 100644
index 0000000..dbd7faa
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.modular.expect
@@ -0,0 +1,634 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:14:9: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:22:9: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:34:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:42:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:53:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:61:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:72:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:80:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:91:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:99:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:110:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:118:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:130:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:138:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:186:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:194:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:20:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:21:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:28:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:29:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:40:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:41:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:48:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:49:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:59:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:60:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:67:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:68:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:78:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:79:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:86:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:87:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:97:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:98:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:105:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:106:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:116:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:117:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:124:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:125:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:136:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:144:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:173:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:174:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:181:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:182:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:192:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:193:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:200:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:201:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'ConcreteClass' doesn't conform to the bound 'int' of the type variable 'T8' on 'Enum1'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:5: Context: This is the type variable whose bound isn't conformed to.
+// T8 extends F<int>, // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'G<ConcreteClass>' doesn't conform to the bound 'G<int>' of the type variable 'S8' on 'Enum1'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:5: Context: This is the type variable whose bound isn't conformed to.
+// S8 extends G<int> // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:212:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:213:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:220:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:221:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:230:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:231:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:238:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:239:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef Typedef1<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+typedef Typedef2 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+typedef Typedef3<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class1<self::Class1::T1, self::Class1::T2%, self::Class1::T3, self::Class1::T4, self::Class1::T5, self::Class1::T6, self::Class1::T7, self::Class1::T8, self::Class1::S1, self::Class1::S2, self::Class1::S3, self::Class1::S4, self::Class1::S5, self::Class1::S6, self::Class1::S7, self::Class1::S8>
+ : super core::Object::•()
+ ;
+}
+class Class2<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> = core::Object with self::Class<dynamic> /*hasConstConstructor*/ {
+ const synthetic constructor •() → self::Class2<self::Class2::T1, self::Class2::T2%, self::Class2::T3, self::Class2::T4, self::Class2::T5, self::Class2::T6, self::Class2::T7, self::Class2::T8, self::Class2::S1, self::Class2::S2, self::Class2::S3, self::Class2::S4, self::Class2::S5, self::Class2::S6, self::Class2::S7, self::Class2::S8>
+ : super core::Object::•()
+ ;
+}
+abstract class Mixin1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object /*isMixinDeclaration*/ {
+}
+class Enum1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>> values = #C4;
+ static const field self::Enum1<self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>> a = #C3;
+ const constructor •(core::int index, core::String name) → self::Enum1<self::Enum1::T1, self::Enum1::T2%, self::Enum1::T3, self::Enum1::T4, self::Enum1::T5, self::Enum1::T6, self::Enum1::T7, self::Enum1::T8, self::Enum1::S1, self::Enum1::S2, self::Enum1::S3, self::Enum1::S4, self::Enum1::S5, self::Enum1::S6, self::Enum1::S7, self::Enum1::S8>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "Enum1.${this.{core::_Enum::_name}{core::String}}";
+}
+extension Extension<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>> on self::Class<dynamic> {
+}
+static method method1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void {}
+static method test() → dynamic {
+ function local1<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void {}
+ <T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void local;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::Enum1<self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*> {index:#C1, _name:#C2}
+ #C4 = <self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_type_parameters.dart:
+- Enum1. (from org-dartlang-testcase:///bounds_type_parameters.dart:129:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.outline.expect
new file mode 100644
index 0000000..ad2a952
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.outline.expect
@@ -0,0 +1,546 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:14:9: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:22:9: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:34:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:42:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:53:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:61:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:72:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:80:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:91:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:99:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:110:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:118:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:130:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:138:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:186:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:194:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:20:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:21:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:28:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:29:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:40:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:41:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:48:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:49:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:59:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:60:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:67:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:68:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:78:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:79:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:86:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:87:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:97:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:98:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:105:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:106:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:116:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:117:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:124:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:125:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:136:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:144:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:173:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:174:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:181:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:182:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:192:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:193:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:200:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:201:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'ConcreteClass' doesn't conform to the bound 'int' of the type variable 'T8' on 'Enum1'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:5: Context: This is the type variable whose bound isn't conformed to.
+// T8 extends F<int>, // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'G<ConcreteClass>' doesn't conform to the bound 'G<int>' of the type variable 'S8' on 'Enum1'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:5: Context: This is the type variable whose bound isn't conformed to.
+// S8 extends G<int> // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef Typedef1<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+typedef Typedef2 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+typedef Typedef3<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+class Class1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class1<self::Class1::T1, self::Class1::T2%, self::Class1::T3, self::Class1::T4, self::Class1::T5, self::Class1::T6, self::Class1::T7, self::Class1::T8, self::Class1::S1, self::Class1::S2, self::Class1::S3, self::Class1::S4, self::Class1::S5, self::Class1::S6, self::Class1::S7, self::Class1::S8>
+ ;
+}
+class Class2<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> = core::Object with self::Class<dynamic> /*hasConstConstructor*/ {
+ const synthetic constructor •() → self::Class2<self::Class2::T1, self::Class2::T2%, self::Class2::T3, self::Class2::T4, self::Class2::T5, self::Class2::T6, self::Class2::T7, self::Class2::T8, self::Class2::S1, self::Class2::S2, self::Class2::S3, self::Class2::S4, self::Class2::S5, self::Class2::S6, self::Class2::S7, self::Class2::S8>
+ : super core::Object::•()
+ ;
+}
+abstract class Mixin1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object /*isMixinDeclaration*/ {
+}
+class Enum1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>> values = const <self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>>[self::Enum1::a];
+ static const field self::Enum1<self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>> a = const self::Enum1::•<self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>>(0, "a");
+ const constructor •(core::int index, core::String name) → self::Enum1<self::Enum1::T1, self::Enum1::T2%, self::Enum1::T3, self::Enum1::T4, self::Enum1::T5, self::Enum1::T6, self::Enum1::T7, self::Enum1::T8, self::Enum1::S1, self::Enum1::S2, self::Enum1::S3, self::Enum1::S4, self::Enum1::S5, self::Enum1::S6, self::Enum1::S7, self::Enum1::S8>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "Enum1.${this.{core::_Enum::_name}{core::String}}";
+}
+extension Extension<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>> on self::Class<dynamic> {
+}
+static method method1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void
+ ;
+static method test() → dynamic
+ ;
+static method main() → dynamic
+ ;
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///bounds_type_parameters.dart:129:6 -> ListConstant(const <Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>*>[const Enum1<ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*>{_Enum.index: 0, _Enum._name: "a"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///bounds_type_parameters.dart:147:3 -> InstanceConstant(const Enum1<ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, ConcreteClass*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*, G<ConcreteClass*>*>{_Enum.index: 0, _Enum._name: "a"})
+Extra constant evaluation: evaluated: 7, effectively constant: 2
diff --git a/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.transformed.expect
new file mode 100644
index 0000000..9bede0a
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_type_parameters.dart.weak.transformed.expect
@@ -0,0 +1,634 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:14:9: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:22:9: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:34:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:42:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:53:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:61:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:72:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:80:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:91:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:99:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:110:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:118:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:130:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:138:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:186:5: Error: Generic type 'F' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'F' here.
+// T1 extends F, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: Bound of this variable references variable 'X' from the same declaration.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:194:5: Error: Generic type 'G' can't be used without type arguments in a type variable bound.
+// Try providing type arguments to 'G' here.
+// S1 extends G, // Error
+// ^^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: Bound of this variable references variable 'X' from the same declaration.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:20:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:21:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:28:20: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:29:20: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:40:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:41:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:48:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:49:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:59:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:60:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:67:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:68:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:78:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:79:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:86:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:87:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:97:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:98:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:105:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:106:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:116:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:117:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:124:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:125:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:136:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:144:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:173:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:174:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:181:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:182:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:192:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:193:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:200:16: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:201:16: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'ConcreteClass' doesn't conform to the bound 'int' of the type variable 'T8' on 'Enum1'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:137:5: Context: This is the type variable whose bound isn't conformed to.
+// T8 extends F<int>, // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:147:3: Error: Type argument 'G<ConcreteClass>' doesn't conform to the bound 'G<int>' of the type variable 'S8' on 'Enum1'.
+// - 'G' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// - 'ConcreteClass' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// a<
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:145:5: Context: This is the type variable whose bound isn't conformed to.
+// S8 extends G<int> // Error
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:212:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:213:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:220:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:221:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:230:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T7 extends F<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:231:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// T8 extends F<int>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:238:18: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S7 extends G<Object>, // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:239:18: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_type_parameters.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// S8 extends G<int> // Error
+// ^
+// pkg/front_end/testcases/general/bounds_type_parameters.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+typedef Typedef1<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+typedef Typedef2 = <T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void;
+typedef Typedef3<unrelated T1 extends self::Class<dynamic> = dynamic, unrelated T2 extends dynamic, unrelated T3 extends self::Class<dynamic> = dynamic, unrelated T4 extends self::Class<dynamic> = dynamic, unrelated T5 extends self::ConcreteClass = dynamic, unrelated T6 extends self::Class<self::ConcreteClass> = dynamic, unrelated T7 extends core::Object = dynamic, unrelated T8 extends core::int = dynamic, unrelated S1 extends self::G<self::Class<dynamic>> = dynamic, unrelated S2 extends self::G<dynamic> = dynamic, unrelated S3 extends self::G<self::Class<dynamic>> = dynamic, unrelated S4 extends self::G<self::Class<dynamic>> = dynamic, unrelated S5 extends self::G<self::ConcreteClass> = dynamic, unrelated S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, unrelated S7 extends self::G<core::Object> = dynamic, unrelated S8 extends self::G<core::int> = dynamic> = () → void;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+class Class1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class1<self::Class1::T1, self::Class1::T2%, self::Class1::T3, self::Class1::T4, self::Class1::T5, self::Class1::T6, self::Class1::T7, self::Class1::T8, self::Class1::S1, self::Class1::S2, self::Class1::S3, self::Class1::S4, self::Class1::S5, self::Class1::S6, self::Class1::S7, self::Class1::S8>
+ : super core::Object::•()
+ ;
+}
+class Class2<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object implements self::Class<dynamic> /*isEliminatedMixin,hasConstConstructor*/ {
+ const synthetic constructor •() → self::Class2<self::Class2::T1, self::Class2::T2%, self::Class2::T3, self::Class2::T4, self::Class2::T5, self::Class2::T6, self::Class2::T7, self::Class2::T8, self::Class2::S1, self::Class2::S2, self::Class2::S3, self::Class2::S4, self::Class2::S5, self::Class2::S6, self::Class2::S7, self::Class2::S8>
+ : super core::Object::•()
+ ;
+}
+abstract class Mixin1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::Object /*isMixinDeclaration*/ {
+}
+class Enum1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic> extends core::_Enum /*isEnum*/ {
+ static const field core::List<self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>> values = #C4;
+ static const field self::Enum1<self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::ConcreteClass, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>, self::G<self::ConcreteClass>> a = #C3;
+ const constructor •(core::int index, core::String name) → self::Enum1<self::Enum1::T1, self::Enum1::T2%, self::Enum1::T3, self::Enum1::T4, self::Enum1::T5, self::Enum1::T6, self::Enum1::T7, self::Enum1::T8, self::Enum1::S1, self::Enum1::S2, self::Enum1::S3, self::Enum1::S4, self::Enum1::S5, self::Enum1::S6, self::Enum1::S7, self::Enum1::S8>
+ : super core::_Enum::•(index, name)
+ ;
+ method toString() → core::String
+ return "Enum1.${this.{core::_Enum::_name}{core::String}}";
+}
+extension Extension<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>> on self::Class<dynamic> {
+}
+static method method1<T1 extends self::Class<dynamic> = dynamic, T2 extends dynamic, T3 extends self::Class<dynamic> = dynamic, T4 extends self::Class<dynamic> = dynamic, T5 extends self::ConcreteClass = dynamic, T6 extends self::Class<self::ConcreteClass> = dynamic, T7 extends core::Object = dynamic, T8 extends core::int = dynamic, S1 extends self::G<self::Class<dynamic>> = dynamic, S2 extends self::G<dynamic> = dynamic, S3 extends self::G<self::Class<dynamic>> = dynamic, S4 extends self::G<self::Class<dynamic>> = dynamic, S5 extends self::G<self::ConcreteClass> = dynamic, S6 extends self::G<self::Class<self::ConcreteClass>> = dynamic, S7 extends self::G<core::Object> = dynamic, S8 extends self::G<core::int> = dynamic>() → void {}
+static method test() → dynamic {
+ function local1<T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void {}
+ <T1 extends self::Class<dynamic>, T2 extends dynamic, T3 extends self::Class<dynamic>, T4 extends self::Class<dynamic>, T5 extends self::ConcreteClass, T6 extends self::Class<self::ConcreteClass>, T7 extends core::Object, T8 extends core::int, S1 extends self::G<self::Class<dynamic>>, S2 extends self::G<dynamic>, S3 extends self::G<self::Class<dynamic>>, S4 extends self::G<self::Class<dynamic>>, S5 extends self::G<self::ConcreteClass>, S6 extends self::G<self::Class<self::ConcreteClass>>, S7 extends self::G<core::Object>, S8 extends self::G<core::int>>() → void local;
+}
+static method main() → dynamic {}
+
+constants {
+ #C1 = 0
+ #C2 = "a"
+ #C3 = self::Enum1<self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::ConcreteClass*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*, self::G<self::ConcreteClass*>*> {index:#C1, _name:#C2}
+ #C4 = <self::Enum1<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///bounds_type_parameters.dart:
+- Enum1. (from org-dartlang-testcase:///bounds_type_parameters.dart:129:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:103:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart b/pkg/front_end/testcases/general/bounds_variables.dart
new file mode 100644
index 0000000..244219f
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart
@@ -0,0 +1,110 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+test1() {
+ F local1a, local1b; // Ok
+ F<dynamic> local2a, local2b; // Ok
+ F<Class> local3a, local3b; // Ok
+ F<Class<dynamic>> local4a, local4b; // Ok
+ F<ConcreteClass> local5a, local5b; // Ok
+ F<Class<ConcreteClass>> local6a, local6b; // Ok
+ F<Object> local7a, local7b; // Error
+ F<int> local8a, local8b; // Error
+ G local1c, local1d; // Ok
+ G<dynamic> local2c, local2d; // Ok
+ G<Class> local3c, local3d; // Ok
+ G<Class<dynamic>> local4c, local4d; // Ok
+ G<ConcreteClass> local5c, local5d; // Ok
+ G<Class<ConcreteClass>> local6c, local6d; // Ok
+ G<Object> local7c, local8d; // Error
+ G<int> local8c, local7d; // Error
+}
+
+test2() {
+ void Function(F) local1a, local1b; // Ok
+ void Function(F<dynamic>) local2a, local2b; // Ok
+ void Function(F<Class>) local3a, local3b; // Ok
+ void Function(F<Class<dynamic>>) local4a, local4b; // Ok
+ void Function(F<ConcreteClass>) local5a, local5b; // Ok
+ void Function(F<Class<ConcreteClass>>) local6a, local6b; // Ok
+ void Function(F<Object>) local7a, local7b; // Error
+ void Function(F<int>) local8a, local8b; // Error
+ void Function(G) local1c, local1d; // Ok
+ void Function(G<dynamic>) local2c, local2d; // Ok
+ void Function(G<Class>) local3c, local3d; // Ok
+ void Function(G<Class<dynamic>>) local4c, local4d; // Ok
+ void Function(G<ConcreteClass>) local5c, local5d; // Ok
+ void Function(G<Class<ConcreteClass>>) local6c, local6d; // Ok
+ void Function(G<Object>) local7c, local8d; // Error
+ void Function(G<int>) local8c, local7d; // Error
+}
+
+test3() {
+ void Function(F f) local1a, local1b; // Ok
+ void Function(F<dynamic> f) local2a, local2b; // Ok
+ void Function(F<Class> f) local3a, local3b; // Ok
+ void Function(F<Class<dynamic>> f) local4a, local4b; // Ok
+ void Function(F<ConcreteClass> f) local5a, local5b; // Ok
+ void Function(F<Class<ConcreteClass>> f) local6a, local6b; // Ok
+ void Function(F<Object> f) local7a, local7b; // Error
+ void Function(F<int> f) local8a, local8b; // Error
+ void Function(G g) local1c, local1d; // Ok
+ void Function(G<dynamic> g) local2c, local2d; // Ok
+ void Function(G<Class> g) local3c, local3d; // Ok
+ void Function(G<Class<dynamic>> g) local4c, local4d; // Ok
+ void Function(G<ConcreteClass> g) local5c, local5d; // Ok
+ void Function(G<Class<ConcreteClass>> g) local6c, local6d; // Ok
+ void Function(G<Object> g) local7c, local8d; // Error
+ void Function(G<int> g) local8c, local7d; // Error
+}
+
+test4() {
+ void Function(void Function(F)) local1a, local1b; // Ok
+ void Function(void Function(F<dynamic>)) local2a, local2b; // Ok
+ void Function(void Function(F<Class>)) local3a, local3b; // Ok
+ void Function(void Function(F<Class<dynamic>>)) local4a, local4b; // Ok
+ void Function(void Function(F<ConcreteClass>)) local5a, local5b; // Ok
+ void Function(void Function(F<Class<ConcreteClass>>)) local6a, local6b; // Ok
+ void Function(void Function(F<Object>)) local7a, local7b; // Error
+ void Function(void Function(F<int>)) local8a, local8b; // Error
+ void Function(void Function(G)) local1c, local1d; // Ok
+ void Function(void Function(G<dynamic>)) local2c, local2d; // Ok
+ void Function(void Function(G<Class>)) local3c, local3d; // Ok
+ void Function(void Function(G<Class<dynamic>>)) local4c, local4d; // Ok
+ void Function(void Function(G<ConcreteClass>)) local5c, local5d; // Ok
+ void Function(void Function(G<Class<ConcreteClass>>)) local6c, local6d; // Ok
+ void Function(void Function(G<Object>)) local7c, local8d; // Error
+ void Function(void Function(G<int>)) local8c, local7d; // Error
+}
+
+test5() {
+ void Function(void Function(F f) f) local1a, local1b; // Ok
+ void Function(void Function(F<dynamic> f) f) local2a, local2b; // Ok
+ void Function(void Function(F<Class> f) f) local3a, local3b; // Ok
+ void Function(void Function(F<Class<dynamic>> f) f) local4a, local4b; // Ok
+ void Function(void Function(F<ConcreteClass> f) f) local5a, local5b; // Ok
+ void Function(void Function(F<Class<ConcreteClass>> f) f) local6a,
+ local6b; // Ok
+ void Function(void Function(F<Object> f) f) local7a, local7b; // Error
+ void Function(void Function(F<int> f) f) local8a, local8b; // Error
+ void Function(void Function(G g) g) local1c, local1d; // Ok
+ void Function(void Function(G<dynamic> g) g) local2c, local2d; // Ok
+ void Function(void Function(G<Class> g) g) local3c, local3d; // Ok
+ void Function(void Function(G<Class<dynamic>> g) g) local4c, local4d; // Ok
+ void Function(void Function(G<ConcreteClass> g) g) local5c, local5d; // Ok
+ void Function(void Function(G<Class<ConcreteClass>> g) g) local6c,
+ local6d; // Ok
+ void Function(void Function(G<Object> g) g) local7c, local8d; // Error
+ void Function(void Function(G<int> g) g) local8c, local7d; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline.expect b/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline.expect
new file mode 100644
index 0000000..27ec92e
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline.expect
@@ -0,0 +1,14 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+typedef F<X extends Class<X>> = X;
+
+class G<X extends Class<X>> {}
+
+test1() {}
+test2() {}
+test3() {}
+test4() {}
+test5() {}
+main() {}
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..61c13bb
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.textual_outline_modelled.expect
@@ -0,0 +1,13 @@
+class Class<T> {}
+
+class ConcreteClass implements Class<ConcreteClass> {}
+
+class G<X extends Class<X>> {}
+
+main() {}
+test1() {}
+test2() {}
+test3() {}
+test4() {}
+test5() {}
+typedef F<X extends Class<X>> = X;
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.weak.expect b/pkg/front_end/testcases/general/bounds_variables.dart.weak.expect
new file mode 100644
index 0000000..e0d7046
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.weak.expect
@@ -0,0 +1,384 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:28:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:29:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:39:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object>) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:40:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int>) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:47:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object>) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:48:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int>) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:58:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object> f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:59:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int> f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:66:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object> g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:67:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int> g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:77:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object>)) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:78:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int>)) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:85:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object>)) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:86:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int>)) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:97:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object> f) f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:98:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int> f) f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:106:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object> g) g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:107:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int> g) g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test1() → dynamic {
+ self::Class<dynamic> local1a;
+ self::Class<dynamic> local1b;
+ dynamic local2a;
+ dynamic local2b;
+ self::Class<dynamic> local3a;
+ self::Class<dynamic> local3b;
+ self::Class<dynamic> local4a;
+ self::Class<dynamic> local4b;
+ self::ConcreteClass local5a;
+ self::ConcreteClass local5b;
+ self::Class<self::ConcreteClass> local6a;
+ self::Class<self::ConcreteClass> local6b;
+ core::Object local7a;
+ core::Object local7b;
+ core::int local8a;
+ core::int local8b;
+ self::G<self::Class<dynamic>> local1c;
+ self::G<self::Class<dynamic>> local1d;
+ self::G<dynamic> local2c;
+ self::G<dynamic> local2d;
+ self::G<self::Class<dynamic>> local3c;
+ self::G<self::Class<dynamic>> local3d;
+ self::G<self::Class<dynamic>> local4c;
+ self::G<self::Class<dynamic>> local4d;
+ self::G<self::ConcreteClass> local5c;
+ self::G<self::ConcreteClass> local5d;
+ self::G<self::Class<self::ConcreteClass>> local6c;
+ self::G<self::Class<self::ConcreteClass>> local6d;
+ self::G<core::Object> local7c;
+ self::G<core::Object> local8d;
+ self::G<core::int> local8c;
+ self::G<core::int> local7d;
+}
+static method test2() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test3() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test4() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method test5() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.weak.modular.expect b/pkg/front_end/testcases/general/bounds_variables.dart.weak.modular.expect
new file mode 100644
index 0000000..e0d7046
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.weak.modular.expect
@@ -0,0 +1,384 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:28:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:29:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:39:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object>) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:40:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int>) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:47:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object>) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:48:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int>) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:58:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object> f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:59:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int> f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:66:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object> g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:67:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int> g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:77:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object>)) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:78:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int>)) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:85:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object>)) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:86:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int>)) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:97:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object> f) f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:98:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int> f) f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:106:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object> g) g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:107:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int> g) g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test1() → dynamic {
+ self::Class<dynamic> local1a;
+ self::Class<dynamic> local1b;
+ dynamic local2a;
+ dynamic local2b;
+ self::Class<dynamic> local3a;
+ self::Class<dynamic> local3b;
+ self::Class<dynamic> local4a;
+ self::Class<dynamic> local4b;
+ self::ConcreteClass local5a;
+ self::ConcreteClass local5b;
+ self::Class<self::ConcreteClass> local6a;
+ self::Class<self::ConcreteClass> local6b;
+ core::Object local7a;
+ core::Object local7b;
+ core::int local8a;
+ core::int local8b;
+ self::G<self::Class<dynamic>> local1c;
+ self::G<self::Class<dynamic>> local1d;
+ self::G<dynamic> local2c;
+ self::G<dynamic> local2d;
+ self::G<self::Class<dynamic>> local3c;
+ self::G<self::Class<dynamic>> local3d;
+ self::G<self::Class<dynamic>> local4c;
+ self::G<self::Class<dynamic>> local4d;
+ self::G<self::ConcreteClass> local5c;
+ self::G<self::ConcreteClass> local5d;
+ self::G<self::Class<self::ConcreteClass>> local6c;
+ self::G<self::Class<self::ConcreteClass>> local6d;
+ self::G<core::Object> local7c;
+ self::G<core::Object> local8d;
+ self::G<core::int> local8c;
+ self::G<core::int> local7d;
+}
+static method test2() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test3() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test4() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method test5() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.weak.outline.expect b/pkg/front_end/testcases/general/bounds_variables.dart.weak.outline.expect
new file mode 100644
index 0000000..786cea6
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.weak.outline.expect
@@ -0,0 +1,29 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ ;
+}
+static method test1() → dynamic
+ ;
+static method test2() → dynamic
+ ;
+static method test3() → dynamic
+ ;
+static method test4() → dynamic
+ ;
+static method test5() → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/bounds_variables.dart.weak.transformed.expect b/pkg/front_end/testcases/general/bounds_variables.dart.weak.transformed.expect
new file mode 100644
index 0000000..e0d7046
--- /dev/null
+++ b/pkg/front_end/testcases/general/bounds_variables.dart.weak.transformed.expect
@@ -0,0 +1,384 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:20:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<Object> local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:21:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<int> local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:28:3: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<Object> local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:29:3: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// G<int> local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:39:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object>) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:40:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int>) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:47:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object>) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:48:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int>) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:58:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<Object> f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:59:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(F<int> f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:66:17: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<Object> g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:67:17: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(G<int> g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:77:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object>)) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:78:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int>)) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:85:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object>)) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:86:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int>)) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:97:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<Object> f) f) local7a, local7b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:98:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'F'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(F<int> f) f) local8a, local8b; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends Class<X>> = X;
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:106:31: Error: Type argument 'Object' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Object' is from 'dart:core'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<Object> g) g) local7c, local8d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+// pkg/front_end/testcases/general/bounds_variables.dart:107:31: Error: Type argument 'int' doesn't conform to the bound 'Class<X>' of the type variable 'X' on 'G'.
+// - 'Class' is from 'pkg/front_end/testcases/general/bounds_variables.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void Function(void Function(G<int> g) g) local8c, local7d; // Error
+// ^
+// pkg/front_end/testcases/general/bounds_variables.dart:11:9: Context: This is the type variable whose bound isn't conformed to.
+// class G<X extends Class<X>> {}
+// ^
+//
+import self as self;
+import "dart:core" as core;
+
+typedef F<X extends self::Class<X> = self::Class<dynamic>> = X;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T%>
+ : super core::Object::•()
+ ;
+}
+class ConcreteClass extends core::Object implements self::Class<self::ConcreteClass> {
+ synthetic constructor •() → self::ConcreteClass
+ : super core::Object::•()
+ ;
+}
+class G<X extends self::Class<self::G::X> = self::Class<dynamic>> extends core::Object {
+ synthetic constructor •() → self::G<self::G::X>
+ : super core::Object::•()
+ ;
+}
+static method test1() → dynamic {
+ self::Class<dynamic> local1a;
+ self::Class<dynamic> local1b;
+ dynamic local2a;
+ dynamic local2b;
+ self::Class<dynamic> local3a;
+ self::Class<dynamic> local3b;
+ self::Class<dynamic> local4a;
+ self::Class<dynamic> local4b;
+ self::ConcreteClass local5a;
+ self::ConcreteClass local5b;
+ self::Class<self::ConcreteClass> local6a;
+ self::Class<self::ConcreteClass> local6b;
+ core::Object local7a;
+ core::Object local7b;
+ core::int local8a;
+ core::int local8b;
+ self::G<self::Class<dynamic>> local1c;
+ self::G<self::Class<dynamic>> local1d;
+ self::G<dynamic> local2c;
+ self::G<dynamic> local2d;
+ self::G<self::Class<dynamic>> local3c;
+ self::G<self::Class<dynamic>> local3d;
+ self::G<self::Class<dynamic>> local4c;
+ self::G<self::Class<dynamic>> local4d;
+ self::G<self::ConcreteClass> local5c;
+ self::G<self::ConcreteClass> local5d;
+ self::G<self::Class<self::ConcreteClass>> local6c;
+ self::G<self::Class<self::ConcreteClass>> local6d;
+ self::G<core::Object> local7c;
+ self::G<core::Object> local8d;
+ self::G<core::int> local8c;
+ self::G<core::int> local7d;
+}
+static method test2() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test3() → dynamic {
+ (self::Class<dynamic>) → void local1a;
+ (self::Class<dynamic>) → void local1b;
+ (dynamic) → void local2a;
+ (dynamic) → void local2b;
+ (self::Class<dynamic>) → void local3a;
+ (self::Class<dynamic>) → void local3b;
+ (self::Class<dynamic>) → void local4a;
+ (self::Class<dynamic>) → void local4b;
+ (self::ConcreteClass) → void local5a;
+ (self::ConcreteClass) → void local5b;
+ (self::Class<self::ConcreteClass>) → void local6a;
+ (self::Class<self::ConcreteClass>) → void local6b;
+ (core::Object) → void local7a;
+ (core::Object) → void local7b;
+ (core::int) → void local8a;
+ (core::int) → void local8b;
+ (self::G<self::Class<dynamic>>) → void local1c;
+ (self::G<self::Class<dynamic>>) → void local1d;
+ (self::G<dynamic>) → void local2c;
+ (self::G<dynamic>) → void local2d;
+ (self::G<self::Class<dynamic>>) → void local3c;
+ (self::G<self::Class<dynamic>>) → void local3d;
+ (self::G<self::Class<dynamic>>) → void local4c;
+ (self::G<self::Class<dynamic>>) → void local4d;
+ (self::G<self::ConcreteClass>) → void local5c;
+ (self::G<self::ConcreteClass>) → void local5d;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6c;
+ (self::G<self::Class<self::ConcreteClass>>) → void local6d;
+ (self::G<core::Object>) → void local7c;
+ (self::G<core::Object>) → void local8d;
+ (self::G<core::int>) → void local8c;
+ (self::G<core::int>) → void local7d;
+}
+static method test4() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method test5() → dynamic {
+ ((self::Class<dynamic>) → void) → void local1a;
+ ((self::Class<dynamic>) → void) → void local1b;
+ ((dynamic) → void) → void local2a;
+ ((dynamic) → void) → void local2b;
+ ((self::Class<dynamic>) → void) → void local3a;
+ ((self::Class<dynamic>) → void) → void local3b;
+ ((self::Class<dynamic>) → void) → void local4a;
+ ((self::Class<dynamic>) → void) → void local4b;
+ ((self::ConcreteClass) → void) → void local5a;
+ ((self::ConcreteClass) → void) → void local5b;
+ ((self::Class<self::ConcreteClass>) → void) → void local6a;
+ ((self::Class<self::ConcreteClass>) → void) → void local6b;
+ ((core::Object) → void) → void local7a;
+ ((core::Object) → void) → void local7b;
+ ((core::int) → void) → void local8a;
+ ((core::int) → void) → void local8b;
+ ((self::G<self::Class<dynamic>>) → void) → void local1c;
+ ((self::G<self::Class<dynamic>>) → void) → void local1d;
+ ((self::G<dynamic>) → void) → void local2c;
+ ((self::G<dynamic>) → void) → void local2d;
+ ((self::G<self::Class<dynamic>>) → void) → void local3c;
+ ((self::G<self::Class<dynamic>>) → void) → void local3d;
+ ((self::G<self::Class<dynamic>>) → void) → void local4c;
+ ((self::G<self::Class<dynamic>>) → void) → void local4d;
+ ((self::G<self::ConcreteClass>) → void) → void local5c;
+ ((self::G<self::ConcreteClass>) → void) → void local5d;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6c;
+ ((self::G<self::Class<self::ConcreteClass>>) → void) → void local6d;
+ ((self::G<core::Object>) → void) → void local7c;
+ ((self::G<core::Object>) → void) → void local8d;
+ ((self::G<core::int>) → void) → void local8c;
+ ((self::G<core::int>) → void) → void local7d;
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/clone_function_type.dart.weak.expect b/pkg/front_end/testcases/general/clone_function_type.dart.weak.expect
index 17fbc7c..699f60e 100644
--- a/pkg/front_end/testcases/general/clone_function_type.dart.weak.expect
+++ b/pkg/front_end/testcases/general/clone_function_type.dart.weak.expect
@@ -32,70 +32,70 @@
// class Ef1<X extends Function({int})> {
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:67:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:67:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Bm2<Z> extends Object with Am2<Function(int), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:70:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:70:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Cm2<Z> extends Object with Am2<Function(int x), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:86:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:86:34: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Jm2<Z> extends Object with Am2<Function, Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:89:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:89:34: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Km2<Z> extends Object with Am2<Function(Function Function), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:95:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Mm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:95:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Mm2<Z> = Object with Am2<Function(int), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:98:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Nm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:98:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Nm2<Z> = Object with Am2<Function(int x), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:114:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Um2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:114:28: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Um2<Z> = Object with Am2<Function, Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:117:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Vm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:117:28: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Vm2<Z> = Object with Am2<Function(Function Function), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
diff --git a/pkg/front_end/testcases/general/clone_function_type.dart.weak.modular.expect b/pkg/front_end/testcases/general/clone_function_type.dart.weak.modular.expect
index 17fbc7c..699f60e 100644
--- a/pkg/front_end/testcases/general/clone_function_type.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/clone_function_type.dart.weak.modular.expect
@@ -32,70 +32,70 @@
// class Ef1<X extends Function({int})> {
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:67:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:67:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Bm2<Z> extends Object with Am2<Function(int), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:70:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:70:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Cm2<Z> extends Object with Am2<Function(int x), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:86:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:86:34: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Jm2<Z> extends Object with Am2<Function, Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:89:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:89:34: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Km2<Z> extends Object with Am2<Function(Function Function), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:95:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Mm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:95:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Mm2<Z> = Object with Am2<Function(int), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:98:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Nm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:98:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Nm2<Z> = Object with Am2<Function(int x), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:114:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Um2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:114:28: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Um2<Z> = Object with Am2<Function, Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:117:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Vm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:117:28: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Vm2<Z> = Object with Am2<Function(Function Function), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
diff --git a/pkg/front_end/testcases/general/clone_function_type.dart.weak.outline.expect b/pkg/front_end/testcases/general/clone_function_type.dart.weak.outline.expect
index 118b670..a3766e6 100644
--- a/pkg/front_end/testcases/general/clone_function_type.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/clone_function_type.dart.weak.outline.expect
@@ -32,70 +32,70 @@
// class Ef1<X extends Function({int})> {
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:67:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:67:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Bm2<Z> extends Object with Am2<Function(int), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:70:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:70:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Cm2<Z> extends Object with Am2<Function(int x), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:86:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:86:34: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Jm2<Z> extends Object with Am2<Function, Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:89:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:89:34: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Km2<Z> extends Object with Am2<Function(Function Function), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:95:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Mm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:95:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Mm2<Z> = Object with Am2<Function(int), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:98:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Nm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:98:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Nm2<Z> = Object with Am2<Function(int x), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:114:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Um2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:114:28: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Um2<Z> = Object with Am2<Function, Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:117:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Vm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:117:28: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Vm2<Z> = Object with Am2<Function(Function Function), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
diff --git a/pkg/front_end/testcases/general/clone_function_type.dart.weak.transformed.expect b/pkg/front_end/testcases/general/clone_function_type.dart.weak.transformed.expect
index 44336bf..6e346c2 100644
--- a/pkg/front_end/testcases/general/clone_function_type.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/clone_function_type.dart.weak.transformed.expect
@@ -32,70 +32,70 @@
// class Ef1<X extends Function({int})> {
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:67:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:67:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Bm2<Z> extends Object with Am2<Function(int), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:70:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:70:34: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Cm2<Z> extends Object with Am2<Function(int x), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:86:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:86:34: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Jm2<Z> extends Object with Am2<Function, Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:89:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Object with Am2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:89:34: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Km2<Z> extends Object with Am2<Function(Function Function), Z> {}
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:95:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Mm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:95:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Mm2<Z> = Object with Am2<Function(int), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:98:7: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Nm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:98:28: Error: Type argument 'dynamic Function(int)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// Try changing type arguments so that they conform to the bounds.
// class Nm2<Z> = Object with Am2<Function(int x), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:114:7: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Um2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:114:28: Error: Type argument 'Function' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Um2<Z> = Object with Am2<Function, Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
//
-// pkg/front_end/testcases/general/clone_function_type.dart:117:7: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2' in the supertype 'Am2' of class 'Vm2'.
+// pkg/front_end/testcases/general/clone_function_type.dart:117:28: Error: Type argument 'dynamic Function(Function)' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'Am2'.
// - 'Function' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// class Vm2<Z> = Object with Am2<Function(Function Function), Z>;
-// ^
+// ^
// pkg/front_end/testcases/general/clone_function_type.dart:64:11: Context: This is the type variable whose bound isn't conformed to.
// class Am2<X extends Function(), Y> {}
// ^
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart
new file mode 100644
index 0000000..a61fd37
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2022, 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.
+
+// @dart=2.12
+
+typedef F = void Function<T>();
+
+T method<T>() => throw '';
+
+test(F f) {
+ f = method();
+ var list = [f];
+ var set = {f};
+ var map1 = {f: 1};
+ var map2 = {1: f};
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline.expect
new file mode 100644
index 0000000..f825256
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline.expect
@@ -0,0 +1,5 @@
+// @dart = 2.12
+typedef F = void Function<T>();
+T method<T>() => throw '';
+test(F f) {}
+main() {}
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..edecddf
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.textual_outline_modelled.expect
@@ -0,0 +1,5 @@
+// @dart = 2.12
+T method<T>() => throw '';
+main() {}
+test(F f) {}
+typedef F = void Function<T>();
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.expect
new file mode 100644
index 0000000..07471ec
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.expect
@@ -0,0 +1,47 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:12:7: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// f = method();
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:13:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var list = [f];
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:14:13: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var set = {f};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:15:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map1 = {f: 1};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:16:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map2 = {1: f};
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F = <T extends core::Object? = dynamic>() → void;
+static method method<T extends core::Object? = dynamic>() → self::method::T%
+ return throw "";
+static method test(<T extends core::Object? = dynamic>() → void f) → dynamic {
+ f = self::method<<T extends core::Object? = dynamic>() → void>();
+ core::List<<T extends core::Object? = dynamic>() → void> list = <<T extends core::Object? = dynamic>() → void>[f];
+ core::Set<<T extends core::Object? = dynamic>() → void> set = block {
+ final core::Set<<T extends core::Object? = dynamic>() → void> #t1 = col::LinkedHashSet::•<<T extends core::Object? = dynamic>() → void>();
+ #t1.{core::Set::add}{Invariant}(f){(<T extends core::Object? = dynamic>() → void) → core::bool};
+ } =>#t1;
+ core::Map<<T extends core::Object? = dynamic>() → void, core::int> map1 = <<T extends core::Object? = dynamic>() → void, core::int>{f: 1};
+ core::Map<core::int, <T extends core::Object? = dynamic>() → void> map2 = <core::int, <T extends core::Object? = dynamic>() → void>{1: f};
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.modular.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.modular.expect
new file mode 100644
index 0000000..07471ec
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.modular.expect
@@ -0,0 +1,47 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:12:7: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// f = method();
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:13:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var list = [f];
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:14:13: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var set = {f};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:15:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map1 = {f: 1};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:16:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map2 = {1: f};
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F = <T extends core::Object? = dynamic>() → void;
+static method method<T extends core::Object? = dynamic>() → self::method::T%
+ return throw "";
+static method test(<T extends core::Object? = dynamic>() → void f) → dynamic {
+ f = self::method<<T extends core::Object? = dynamic>() → void>();
+ core::List<<T extends core::Object? = dynamic>() → void> list = <<T extends core::Object? = dynamic>() → void>[f];
+ core::Set<<T extends core::Object? = dynamic>() → void> set = block {
+ final core::Set<<T extends core::Object? = dynamic>() → void> #t1 = col::LinkedHashSet::•<<T extends core::Object? = dynamic>() → void>();
+ #t1.{core::Set::add}{Invariant}(f){(<T extends core::Object? = dynamic>() → void) → core::bool};
+ } =>#t1;
+ core::Map<<T extends core::Object? = dynamic>() → void, core::int> map1 = <<T extends core::Object? = dynamic>() → void, core::int>{f: 1};
+ core::Map<core::int, <T extends core::Object? = dynamic>() → void> map2 = <core::int, <T extends core::Object? = dynamic>() → void>{1: f};
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.outline.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.outline.expect
new file mode 100644
index 0000000..b8d645e
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.outline.expect
@@ -0,0 +1,11 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F = <T extends core::Object? = dynamic>() → void;
+static method method<T extends core::Object? = dynamic>() → self::method::T%
+ ;
+static method test(<T extends core::Object? = dynamic>() → void f) → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.transformed.expect b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.transformed.expect
new file mode 100644
index 0000000..ccf2bce
--- /dev/null
+++ b/pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart.weak.transformed.expect
@@ -0,0 +1,47 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:12:7: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// f = method();
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:13:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var list = [f];
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:14:13: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var set = {f};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:15:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map1 = {f: 1};
+// ^
+//
+// pkg/front_end/testcases/general/inferred_generic_function_type_argument.dart:16:14: Error: Generic function type 'void Function<T>()' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// var map2 = {1: f};
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+typedef F = <T extends core::Object? = dynamic>() → void;
+static method method<T extends core::Object? = dynamic>() → self::method::T%
+ return throw "";
+static method test(<T extends core::Object? = dynamic>() → void f) → dynamic {
+ f = self::method<<T extends core::Object? = dynamic>() → void>();
+ core::List<<T extends core::Object? = dynamic>() → void> list = core::_GrowableList::_literal1<<T extends core::Object? = dynamic>() → void>(f);
+ core::Set<<T extends core::Object? = dynamic>() → void> set = block {
+ final core::Set<<T extends core::Object? = dynamic>() → void> #t1 = new col::_CompactLinkedHashSet::•<<T extends core::Object? = dynamic>() → void>();
+ #t1.{core::Set::add}{Invariant}(f){(<T extends core::Object? = dynamic>() → void) → core::bool};
+ } =>#t1;
+ core::Map<<T extends core::Object? = dynamic>() → void, core::int> map1 = <<T extends core::Object? = dynamic>() → void, core::int>{f: 1};
+ core::Map<core::int, <T extends core::Object? = dynamic>() → void> map2 = <core::int, <T extends core::Object? = dynamic>() → void>{1: f};
+}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/issue44476.dart.weak.expect b/pkg/front_end/testcases/general/issue44476.dart.weak.expect
index 0f8715b..795ef97 100644
--- a/pkg/front_end/testcases/general/issue44476.dart.weak.expect
+++ b/pkg/front_end/testcases/general/issue44476.dart.weak.expect
@@ -2,58 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/issue44476.dart:7:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:7:5: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// foo(A<num> x) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:8:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// bar(A<num> y) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:9:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// barbar(A<num> yy) => null;
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:9:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:11:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// barbar(A<num> yy) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:8:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// bar(A<num> y) {
+// var baz = (A<num> z) {
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:12:26: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:12:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:12:9: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:7: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
+// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/general/issue44476.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue44476.dart.weak.modular.expect
index 0f8715b..795ef97 100644
--- a/pkg/front_end/testcases/general/issue44476.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/issue44476.dart.weak.modular.expect
@@ -2,58 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/issue44476.dart:7:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:7:5: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// foo(A<num> x) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:8:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// bar(A<num> y) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:9:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// barbar(A<num> yy) => null;
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:9:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:11:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// barbar(A<num> yy) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:8:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// bar(A<num> y) {
+// var baz = (A<num> z) {
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:12:26: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:12:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:12:9: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:7: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
+// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/general/issue44476.dart.weak.outline.expect b/pkg/front_end/testcases/general/issue44476.dart.weak.outline.expect
index ab893e2..47fde5e 100644
--- a/pkg/front_end/testcases/general/issue44476.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/issue44476.dart.weak.outline.expect
@@ -2,10 +2,10 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/issue44476.dart:7:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:7:5: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// foo(A<num> x) {
-// ^
+// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/general/issue44476.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue44476.dart.weak.transformed.expect
index 0f8715b..795ef97 100644
--- a/pkg/front_end/testcases/general/issue44476.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/issue44476.dart.weak.transformed.expect
@@ -2,58 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/issue44476.dart:7:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:7:5: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// foo(A<num> x) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:8:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// bar(A<num> y) {
+// ^
+// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/issue44476.dart:9:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// barbar(A<num> yy) => null;
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:9:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:11:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// barbar(A<num> yy) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:8:14: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// bar(A<num> y) {
+// var baz = (A<num> z) {
// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/issue44476.dart:12:26: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/issue44476.dart:12:19: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:12:9: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var bazbaz = (A<num> zz) => null;
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
-// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/issue44476.dart:11:7: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var baz = (A<num> z) {
-// ^
+// ^
// pkg/front_end/testcases/general/issue44476.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/general/nested_variance2.dart.weak.expect b/pkg/front_end/testcases/general/nested_variance2.dart.weak.expect
index 8c5790b..130bce3 100644
--- a/pkg/front_end/testcases/general/nested_variance2.dart.weak.expect
+++ b/pkg/front_end/testcases/general/nested_variance2.dart.weak.expect
@@ -2,64 +2,36 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
-// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
// pkg/front_end/testcases/general/nested_variance2.dart:84:42: Error: A value of type 'void Function<Y extends Acon<dynamic Function(Never), dynamic>>()' can't be assigned to a variable of type 'void Function<Y extends Acon<dynamic Function(Null), dynamic>>()' because 'Null' is nullable and 'Never' isn't.
// - 'Acon' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// F<Acon<Fcon<Null>, dynamic>> target2 = fsource2;
// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
+// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// ^
//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/general/nested_variance2.dart.weak.modular.expect b/pkg/front_end/testcases/general/nested_variance2.dart.weak.modular.expect
index 8c5790b..130bce3 100644
--- a/pkg/front_end/testcases/general/nested_variance2.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/nested_variance2.dart.weak.modular.expect
@@ -2,64 +2,36 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
-// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
// pkg/front_end/testcases/general/nested_variance2.dart:84:42: Error: A value of type 'void Function<Y extends Acon<dynamic Function(Never), dynamic>>()' can't be assigned to a variable of type 'void Function<Y extends Acon<dynamic Function(Null), dynamic>>()' because 'Null' is nullable and 'Never' isn't.
// - 'Acon' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// F<Acon<Fcon<Null>, dynamic>> target2 = fsource2;
// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
+// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// ^
//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/general/nested_variance2.dart.weak.transformed.expect b/pkg/front_end/testcases/general/nested_variance2.dart.weak.transformed.expect
index 77f1c4c..2b81a6e 100644
--- a/pkg/front_end/testcases/general/nested_variance2.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/nested_variance2.dart.weak.transformed.expect
@@ -2,64 +2,36 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
-// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:177:21: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
-// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'Object' is from 'dart:core'.
-// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
-// ^
-//
// pkg/front_end/testcases/general/nested_variance2.dart:84:42: Error: A value of type 'void Function<Y extends Acon<dynamic Function(Never), dynamic>>()' can't be assigned to a variable of type 'void Function<Y extends Acon<dynamic Function(Null), dynamic>>()' because 'Null' is nullable and 'Never' isn't.
// - 'Acon' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// F<Acon<Fcon<Null>, dynamic>> target2 = fsource2;
// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/general/nested_variance2.dart:177:3: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
-// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// AinvCyclicCoBound source12 = throw ''; //# 02: compile-time error
+// ^
//
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Error: Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
-// Try changing type arguments so that they conform to the bounds.
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Error: Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:49:27: Context: This is the type variable whose bound isn't conformed to.
-// typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);
-// ^
-// pkg/front_end/testcases/general/nested_variance2.dart:236:24: Context: If you want 'FinvCyclicCoBound<dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'B<AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>>' must then satisfy its bounds, which it does not.
-// - 'B' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:57:57: Context: This is the type variable whose bound isn't conformed to.
+// class AinvCyclicCoBound<X extends FinvCyclicCoBound<Y>, Y extends Function(Y)> {
+// ^
+// pkg/front_end/testcases/general/nested_variance2.dart:236:5: Context: If you want 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' to be a super-bounded type, note that the inverted type 'AinvCyclicCoBound<FinvCyclicCoBound<Never Function(Never)>, Never Function(Object?)>' must then satisfy its bounds, which it does not.
// - 'AinvCyclicCoBound' is from 'pkg/front_end/testcases/general/nested_variance2.dart'.
// - 'Object' is from 'dart:core'.
// B<AinvCyclicCoBound> source12 = throw ''; //# 04: compile-time error
-// ^
+// ^
//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/general/super_bounded.dart b/pkg/front_end/testcases/general/super_bounded.dart
new file mode 100644
index 0000000..6d74f81
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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.
+
+typedef F<X> = X Function(X);
+
+class A<T> {}
+
+class Class<T extends A<T>> {}
+
+method(Class c1, Class<dynamic> c2) {}
+
+main() {}
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.textual_outline.expect b/pkg/front_end/testcases/general/super_bounded.dart.textual_outline.expect
new file mode 100644
index 0000000..ca7b1c6
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.textual_outline.expect
@@ -0,0 +1,8 @@
+typedef F<X> = X Function(X);
+
+class A<T> {}
+
+class Class<T extends A<T>> {}
+
+method(Class c1, Class<dynamic> c2) {}
+main() {}
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/super_bounded.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..c1e72c5
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.textual_outline_modelled.expect
@@ -0,0 +1,7 @@
+class A<T> {}
+
+class Class<T extends A<T>> {}
+
+main() {}
+method(Class c1, Class<dynamic> c2) {}
+typedef F<X> = X Function(X);
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.weak.expect b/pkg/front_end/testcases/general/super_bounded.dart.weak.expect
new file mode 100644
index 0000000..d6a4196
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.weak.expect
@@ -0,0 +1,17 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class A<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::A<self::A::T%>
+ : super core::Object::•()
+ ;
+}
+class Class<T extends self::A<self::Class::T> = self::A<dynamic>> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T>
+ : super core::Object::•()
+ ;
+}
+static method method(self::Class<self::A<dynamic>> c1, self::Class<dynamic> c2) → dynamic {}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.weak.modular.expect b/pkg/front_end/testcases/general/super_bounded.dart.weak.modular.expect
new file mode 100644
index 0000000..d6a4196
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.weak.modular.expect
@@ -0,0 +1,17 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class A<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::A<self::A::T%>
+ : super core::Object::•()
+ ;
+}
+class Class<T extends self::A<self::Class::T> = self::A<dynamic>> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T>
+ : super core::Object::•()
+ ;
+}
+static method method(self::Class<self::A<dynamic>> c1, self::Class<dynamic> c2) → dynamic {}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.weak.outline.expect b/pkg/front_end/testcases/general/super_bounded.dart.weak.outline.expect
new file mode 100644
index 0000000..7bae477
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.weak.outline.expect
@@ -0,0 +1,17 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class A<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::A<self::A::T%>
+ ;
+}
+class Class<T extends self::A<self::Class::T> = self::A<dynamic>> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T>
+ ;
+}
+static method method(self::Class<self::A<dynamic>> c1, self::Class<dynamic> c2) → dynamic
+ ;
+static method main() → dynamic
+ ;
diff --git a/pkg/front_end/testcases/general/super_bounded.dart.weak.transformed.expect b/pkg/front_end/testcases/general/super_bounded.dart.weak.transformed.expect
new file mode 100644
index 0000000..d6a4196
--- /dev/null
+++ b/pkg/front_end/testcases/general/super_bounded.dart.weak.transformed.expect
@@ -0,0 +1,17 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef F<invariant X extends core::Object? = dynamic> = (X%) → X%;
+class A<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → self::A<self::A::T%>
+ : super core::Object::•()
+ ;
+}
+class Class<T extends self::A<self::Class::T> = self::A<dynamic>> extends core::Object {
+ synthetic constructor •() → self::Class<self::Class::T>
+ : super core::Object::•()
+ ;
+}
+static method method(self::Class<self::A<dynamic>> c1, self::Class<dynamic> c2) → dynamic {}
+static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.expect
index 145ed00..aae0506 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// extension E<X extends A<num>> // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num> staticFieldOfA; // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num> staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// extension E<X extends A<num>> // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// static A<num> fieldOfE; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fooOfE() => null; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void bazOfE<Y extends A<num>>() {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.modular.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.modular.expect
index 145ed00..aae0506 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.modular.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// extension E<X extends A<num>> // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num> staticFieldOfA; // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num> staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// extension E<X extends A<num>> // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// static A<num> fieldOfE; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fooOfE() => null; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void bazOfE<Y extends A<num>>() {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.outline.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.outline.expect
index 401ed4e..e65a4dc 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.outline.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// extension E<X extends A<num>> // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num> staticFieldOfA; // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num> staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// extension E<X extends A<num>> // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// static A<num> fieldOfE; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fooOfE() => null; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void bazOfE<Y extends A<num>>() {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.transformed.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.transformed.expect
index 145ed00..aae0506 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart.weak.transformed.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// extension E<X extends A<num>> // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:10:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num> staticFieldOfA; // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:11:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num> staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:14:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// extension E<X extends A<num>> // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:16:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// static A<num> fieldOfE; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:17:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num> fooOfE() => null; // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:18:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:19:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void bazOfE<Y extends A<num>>() {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.expect
index c19f798..7f9ecea 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// extension E<X extends A<num>> // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? fieldOfE; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fooOfE() => null; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? staticFieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? fieldOfE; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fooOfE() => null; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void barOfE(A<num> a) {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.modular.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.modular.expect
index c19f798..7f9ecea 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.modular.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// extension E<X extends A<num>> // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? fieldOfE; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fooOfE() => null; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? staticFieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? fieldOfE; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fooOfE() => null; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void barOfE(A<num> a) {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.outline.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.outline.expect
index ed99e3a..3047353 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.outline.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// extension E<X extends A<num>> // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? fieldOfE; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fooOfE() => null; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? staticFieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? fieldOfE; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fooOfE() => null; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void barOfE(A<num> a) {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.transformed.expect b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.transformed.expect
index c19f798..7f9ecea 100644
--- a/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart.weak.transformed.expect
@@ -2,57 +2,57 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? staticFieldOfA; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:12:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// extension E<X extends A<num>> // Error.
-// ^
+// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
// ^
//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// static A<num>? fieldOfE; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num>? fooOfE() => null; // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// void barOfE(A<num> a) {} // Error.
-// ^
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:17:25: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// void bazOfE<Y extends A<num>>() {} // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:8:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:9:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? staticFieldOfA; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:14:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// static A<num>? fieldOfE; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:15:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// A<num>? fooOfE() => null; // Error.
+// ^
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:16:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// void barOfE(A<num> a) {} // Error.
// ^
// pkg/front_end/testcases/general/well_boundness_checks_in_outline2.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends int> {}
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart
new file mode 100644
index 0000000..314fc2a
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2022, 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.
+
+// @dart=2.12
+
+import 'alias_from_opt_in_lib.dart';
+
+test(
+ T1 t1a, // Ok
+ List<T1> t1b, // Error
+ void Function(T1) t1c, // Ok
+ void Function(List<T1>) t1d, // Error
+ T2 t2a, // Ok
+ List<T2> t2b, // // Ok
+ void Function(T2) t2c, // Ok
+ void Function(List<T2>) t2d, // // Ok
+ T3 t3a, // Error
+ List<T3> t3b, // Error
+ void Function(T3) t3c, // Error
+ void Function(List<T3>) t3d, // Error
+ T4 t4a, // Error,
+ List<T4> t4b, // Error,
+ void Function(T4) t4c, // Error
+ void Function(List<T4>) t4d, // Error
+) {
+ new T4(); // Error
+ <T4>[]; // Error
+ <void Function(T4)>[]; // Error
+ <void Function(List<T4>)>[]; // Error
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.expect
new file mode 100644
index 0000000..046ad77
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.expect
@@ -0,0 +1,110 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:27:7: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// new T4(); // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:28:4: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <T4>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:29:18: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(T4)>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:30:23: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(List<T4>)>[]; // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+ <ali::Class<<T extends core::Object? = dynamic>(T%) → void>>[];
+ <(ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void>[];
+ <(core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void>[];
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ : super core::Object::•()
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+}
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.transformed.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.transformed.expect
new file mode 100644
index 0000000..0ef0673
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.strong.transformed.expect
@@ -0,0 +1,110 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:27:7: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// new T4(); // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:28:4: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <T4>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:29:18: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(T4)>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:30:23: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(List<T4>)>[]; // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+ core::_GrowableList::•<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>(0);
+ core::_GrowableList::•<(ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void>(0);
+ core::_GrowableList::•<(core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void>(0);
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ : super core::Object::•()
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+}
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline.expect
new file mode 100644
index 0000000..bc7045b
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline.expect
@@ -0,0 +1,22 @@
+// @dart = 2.12
+import 'alias_from_opt_in_lib.dart';
+
+test(
+ T1 t1a,
+ List<T1> t1b,
+ void Function(T1) t1c,
+ void Function(List<T1>) t1d,
+ T2 t2a,
+ List<T2> t2b,
+ void Function(T2) t2c,
+ void Function(List<T2>) t2d,
+ T3 t3a,
+ List<T3> t3b,
+ void Function(T3) t3c,
+ void Function(List<T3>) t3d,
+ T4 t4a,
+ List<T4> t4b,
+ void Function(T4) t4c,
+ void Function(List<T4>) t4d,
+) {}
+main() {}
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..803b7714
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.textual_outline_modelled.expect
@@ -0,0 +1,22 @@
+// @dart = 2.12
+import 'alias_from_opt_in_lib.dart';
+
+main() {}
+test(
+ T1 t1a,
+ List<T1> t1b,
+ void Function(T1) t1c,
+ void Function(List<T1>) t1d,
+ T2 t2a,
+ List<T2> t2b,
+ void Function(T2) t2c,
+ void Function(List<T2>) t2d,
+ T3 t3a,
+ List<T3> t3b,
+ void Function(T3) t3c,
+ void Function(List<T3>) t3d,
+ T4 t4a,
+ List<T4> t4b,
+ void Function(T4) t4c,
+ void Function(List<T4>) t4d,
+) {}
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.expect
new file mode 100644
index 0000000..046ad77
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.expect
@@ -0,0 +1,110 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:27:7: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// new T4(); // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:28:4: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <T4>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:29:18: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(T4)>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:30:23: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(List<T4>)>[]; // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+ <ali::Class<<T extends core::Object? = dynamic>(T%) → void>>[];
+ <(ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void>[];
+ <(core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void>[];
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ : super core::Object::•()
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+}
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.modular.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.modular.expect
new file mode 100644
index 0000000..046ad77
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.modular.expect
@@ -0,0 +1,110 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:27:7: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// new T4(); // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:28:4: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <T4>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:29:18: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(T4)>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:30:23: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(List<T4>)>[]; // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+ <ali::Class<<T extends core::Object? = dynamic>(T%) → void>>[];
+ <(ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void>[];
+ <(core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void>[];
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ : super core::Object::•()
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+}
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.outline.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.outline.expect
new file mode 100644
index 0000000..08796ca
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.outline.expect
@@ -0,0 +1,85 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic
+ ;
+static method main() → dynamic
+ ;
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic
+ ;
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.transformed.expect b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.transformed.expect
new file mode 100644
index 0000000..0ef0673
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart.weak.transformed.expect
@@ -0,0 +1,110 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:11:3: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// List<T1> t1b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:13:17: Error: A generic function type can't be used as a type argument.
+// Try using a non-generic function type.
+// void Function(List<T1>) t1d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:22:3: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// T4 t4a, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:23:8: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// List<T4> t4b, // Error,
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:24:17: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(T4) t4c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:25:22: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T4>) t4d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:18:3: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// T3 t3a, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:19:8: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// List<T3> t3b, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:20:17: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(T3) t3c, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:21:22: Error: Generic function type 'List<void Function<T>(T)>' used as a type argument through typedef 'T3'.
+// - 'List' is from 'dart:core'.
+// Try providing a non-generic function type explicitly.
+// void Function(List<T3>) t3d, // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:27:7: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// new T4(); // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:28:4: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <T4>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:29:18: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(T4)>[]; // Error
+// ^
+//
+// pkg/front_end/testcases/generic_metadata/alias_from_opt_in.dart:30:23: Error: Generic function type 'void Function<T>(T)' inferred as a type argument.
+// Try providing a non-generic function type explicitly.
+// <void Function(List<T4>)>[]; // Error
+// ^
+//
+import self as self;
+import "dart:core" as core;
+import "alias_from_opt_in_lib.dart" as ali;
+
+import "org-dartlang-testcase:///alias_from_opt_in_lib.dart";
+
+static method test(<T extends core::Object? = dynamic>(T%) → void t1a, core::List<<T extends core::Object? = dynamic>(T%) → void> t1b, (<T extends core::Object? = dynamic>(T%) → void) → void t1c, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t1d, (<T extends core::Object? = dynamic>(T%) → void) → void t2a, core::List<(<T extends core::Object? = dynamic>(T%) → void) → void> t2b, ((<T extends core::Object? = dynamic>(T%) → void) → void) → void t2c, (core::List<(<T extends core::Object? = dynamic>(T%) → void) → void>) → void t2d, core::List<<T extends core::Object? = dynamic>(T%) → void> t3a, core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>> t3b, (core::List<<T extends core::Object? = dynamic>(T%) → void>) → void t3c, (core::List<core::List<<T extends core::Object? = dynamic>(T%) → void>>) → void t3d, ali::Class<<T extends core::Object? = dynamic>(T%) → void> t4a, core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>> t4b, (ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void t4c, (core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void t4d) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+ core::_GrowableList::•<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>(0);
+ core::_GrowableList::•<(ali::Class<<T extends core::Object? = dynamic>(T%) → void>) → void>(0);
+ core::_GrowableList::•<(core::List<ali::Class<<T extends core::Object? = dynamic>(T%) → void>>) → void>(0);
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as ali;
+import "dart:core" as core;
+
+typedef T1 = <T extends core::Object? = dynamic>(T%) → void;
+typedef T2 = (<T extends core::Object? = dynamic>(T%) → void) → void;
+typedef T3 = core::List<<T extends core::Object? = dynamic>(T%) → void>;
+typedef T4<X extends <T extends core::Object? = dynamic>(T%) → void> = ali::Class<X>;
+class Class<T extends core::Object? = dynamic> extends core::Object {
+ synthetic constructor •() → ali::Class<ali::Class::T%>
+ : super core::Object::•()
+ ;
+}
+static method test(<T extends core::Object? = dynamic>(T%) → void t1, <T extends core::Object? = dynamic>(T%) → void t2, core::List<<T extends core::Object? = dynamic>(T%) → void> t3) → dynamic {
+ new ali::Class::•<<T extends core::Object? = dynamic>(T%) → void>();
+}
+static method _#T4#new#tearOff<X extends <T extends core::Object? = dynamic>(T%) → void>() → ali::Class<ali::_#T4#new#tearOff::X>
+ return new ali::Class::•<ali::_#T4#new#tearOff::X>();
diff --git a/pkg/front_end/testcases/generic_metadata/alias_from_opt_in_lib.dart b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in_lib.dart
new file mode 100644
index 0000000..b1b273a
--- /dev/null
+++ b/pkg/front_end/testcases/generic_metadata/alias_from_opt_in_lib.dart
@@ -0,0 +1,18 @@
+// Copyright (c) 2022, 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.
+
+class Class<T> {}
+
+typedef T1 = void Function<T>(T);
+typedef T2 = void Function(void Function<T>(T));
+typedef T3 = List<void Function<T>(T)>;
+typedef T4<X extends void Function<T>(T)> = Class<X>;
+
+test(
+ T1 t1, // Ok
+ T1 t2, // Ok
+ T3 t3, // Ok
+) {
+ new T4(); // Ok
+}
diff --git a/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.expect b/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.expect
index 3ed0854..cdeaa48 100644
--- a/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.expect
@@ -12,16 +12,6 @@
// class C<T extends A> {
// ^
//
-// pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart:21:29: Error: Inferred type argument 'NotA' doesn't conform to the bound 'A' of the type variable 'T' on 'C'.
-// - 'NotA' is from 'pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart'.
-// - 'A' is from 'pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var /*@ type=C<NotA*>* */ x =
-// ^
-// pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart:12:9: Context: This is the type variable whose bound isn't conformed to.
-// class C<T extends A> {
-// ^
-//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.modular.expect b/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.modular.expect
index 3ed0854..cdeaa48 100644
--- a/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart.weak.modular.expect
@@ -12,16 +12,6 @@
// class C<T extends A> {
// ^
//
-// pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart:21:29: Error: Inferred type argument 'NotA' doesn't conform to the bound 'A' of the type variable 'T' on 'C'.
-// - 'NotA' is from 'pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart'.
-// - 'A' is from 'pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// var /*@ type=C<NotA*>* */ x =
-// ^
-// pkg/front_end/testcases/inference/constructors_infer_from_arguments_argument_not_assignable.dart:12:9: Context: This is the type variable whose bound isn't conformed to.
-// class C<T extends A> {
-// ^
-//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.expect b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.expect
index 69d5022..05a10e7 100644
--- a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.expect
@@ -2,11 +2,11 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:7: Error: Type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0' in the supertype 'M0' of class 'M1 with M0'.
+// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:25: Error: Inferred type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0'.
// - 'Comparable' is from 'dart:core'.
-// Try changing type arguments so that they conform to the bounds.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// class A extends M1 with M0 {}
-// ^
+// ^
// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:7:13: Context: This is the type variable whose bound isn't conformed to.
// class M0<X, Y extends Comparable<Y>> extends I<X> {}
// ^
diff --git a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.modular.expect b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.modular.expect
index 69d5022..05a10e7 100644
--- a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.modular.expect
@@ -2,11 +2,11 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:7: Error: Type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0' in the supertype 'M0' of class 'M1 with M0'.
+// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:25: Error: Inferred type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0'.
// - 'Comparable' is from 'dart:core'.
-// Try changing type arguments so that they conform to the bounds.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// class A extends M1 with M0 {}
-// ^
+// ^
// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:7:13: Context: This is the type variable whose bound isn't conformed to.
// class M0<X, Y extends Comparable<Y>> extends I<X> {}
// ^
diff --git a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.outline.expect b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.outline.expect
index c887609..98c5c87 100644
--- a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.outline.expect
@@ -2,11 +2,11 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:7: Error: Type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0' in the supertype 'M0' of class 'M1 with M0'.
+// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:25: Error: Inferred type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0'.
// - 'Comparable' is from 'dart:core'.
-// Try changing type arguments so that they conform to the bounds.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// class A extends M1 with M0 {}
-// ^
+// ^
// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:7:13: Context: This is the type variable whose bound isn't conformed to.
// class M0<X, Y extends Comparable<Y>> extends I<X> {}
// ^
diff --git a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.transformed.expect
index c133ecb..06c6423 100644
--- a/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart.weak.transformed.expect
@@ -2,11 +2,11 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:7: Error: Type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0' in the supertype 'M0' of class 'M1 with M0'.
+// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:13:25: Error: Inferred type argument 'Comparable<dynamic>' doesn't conform to the bound 'Comparable<Y>' of the type variable 'Y' on 'M0'.
// - 'Comparable' is from 'dart:core'.
-// Try changing type arguments so that they conform to the bounds.
+// Try specifying type arguments explicitly so that they conform to the bounds.
// class A extends M1 with M0 {}
-// ^
+// ^
// pkg/front_end/testcases/inference/mixin_inference_instantiate_to_bounds_3.dart:7:13: Context: This is the type variable whose bound isn't conformed to.
// class M0<X, Y extends Comparable<Y>> extends I<X> {}
// ^
diff --git a/pkg/front_end/testcases/modular.status b/pkg/front_end/testcases/modular.status
index a3e7ee6..b2aa3a1 100644
--- a/pkg/front_end/testcases/modular.status
+++ b/pkg/front_end/testcases/modular.status
@@ -23,6 +23,7 @@
extensions/extension_setter_error: TypeCheckError
general/abstract_members: TypeCheckError
general/bounded_implicit_instantiation: TypeCheckError
+general/bounds_instances: TypeCheckError
general/bug30695: TypeCheckError
general/covariant_field: TypeCheckError
general/crashes/crash_02/main: Crash
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.expect
index ab741a5..0926cb3 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.transformed.expect
index ab741a5..0926cb3 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.strong.transformed.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.expect
index ab741a5..0926cb3 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.modular.expect
index ab741a5..0926cb3 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.modular.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.outline.expect
index be5c01e..47d8657 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.outline.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.transformed.expect
index ab741a5..0926cb3 100644
--- a/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/bounds_checks.dart.weak.transformed.expect
@@ -2,42 +2,42 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
-// Try changing type arguments so that they conform to the bounds.
-// foo(A<num?> a) {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:13: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the return type.
-// Try changing type arguments so that they conform to the bounds.
-// A<num?>? bar() {} // Error
-// ^
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:11:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// baz<T extends A<num?>>() {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// class C<T extends A<num?>> {} // Error
+// ^
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:7:5: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// Try changing type arguments so that they conform to the bounds.
+// foo(A<num?> a) {} // Error
// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:7: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:9:1: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class B extends A<num?> {} // Error
-// ^
+// A<num?>? bar() {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/bounds_checks.dart:15:9: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/bounds_checks.dart:13:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'A'.
// Try changing type arguments so that they conform to the bounds.
-// class C<T extends A<num?>> {} // Error
-// ^
+// class B extends A<num?> {} // Error
+// ^
// pkg/front_end/testcases/nnbd/bounds_checks.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42429.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue42429.dart.strong.expect
index 717c859..0cbdeae 100644
--- a/pkg/front_end/testcases/nnbd/issue42429.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue42429.dart.strong.expect
@@ -2,192 +2,192 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:13:13: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:13:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// A<Object> aObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:14:11: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:14:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num?> aNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:15:11: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:15:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<int?> aIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:16:11: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:16:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<Null> aNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:17:21: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:17:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object> fArgumentObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:18:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:18:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<num?> fArgumentNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:19:19: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:19:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<int?> fArgumentIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:20:19: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:20:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Null> fArgumentNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:21:19: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:21:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Object> fReturnObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:22:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:22:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<num?> fReturnNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:23:17: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:23:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<int?> fReturnIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:24:17: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:24:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Null> fReturnNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:25:17: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:25:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Object> fBothObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:26:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:26:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<num?> fBothNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:27:15: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:27:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<int?> fBothIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:28:15: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:28:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Null> fBothNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:29:20: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:29:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Object> fNowhereObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:30:18: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:30:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<num?> fNowhereNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:31:18: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:31:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<int?> fNowhereIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:32:18: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:32:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Null> fNowhereNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:33:22: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:33:3: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object?> fArgumentObjectNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:34:22: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:34:3: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<dynamic> fArgumentDynamic; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:35:19: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:35:3: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<void> fArgumentVoid; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42429.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue42429.dart.strong.transformed.expect
index 717c859..0cbdeae 100644
--- a/pkg/front_end/testcases/nnbd/issue42429.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42429.dart.strong.transformed.expect
@@ -2,192 +2,192 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:13:13: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:13:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// A<Object> aObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:14:11: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:14:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num?> aNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:15:11: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:15:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<int?> aIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:16:11: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:16:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<Null> aNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:17:21: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:17:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object> fArgumentObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:18:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:18:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<num?> fArgumentNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:19:19: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:19:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<int?> fArgumentIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:20:19: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:20:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Null> fArgumentNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:21:19: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:21:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Object> fReturnObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:22:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:22:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<num?> fReturnNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:23:17: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:23:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<int?> fReturnIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:24:17: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:24:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Null> fReturnNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:25:17: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:25:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Object> fBothObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:26:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:26:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<num?> fBothNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:27:15: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:27:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<int?> fBothIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:28:15: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:28:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Null> fBothNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:29:20: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:29:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Object> fNowhereObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:30:18: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:30:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<num?> fNowhereNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:31:18: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:31:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<int?> fNowhereIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:32:18: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:32:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Null> fNowhereNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:33:22: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:33:3: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object?> fArgumentObjectNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:34:22: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:34:3: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<dynamic> fArgumentDynamic; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:35:19: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:35:3: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<void> fArgumentVoid; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.expect b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.expect
index 717c859..0cbdeae 100644
--- a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.expect
@@ -2,192 +2,192 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:13:13: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:13:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// A<Object> aObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:14:11: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:14:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num?> aNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:15:11: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:15:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<int?> aIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:16:11: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:16:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<Null> aNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:17:21: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:17:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object> fArgumentObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:18:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:18:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<num?> fArgumentNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:19:19: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:19:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<int?> fArgumentIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:20:19: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:20:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Null> fArgumentNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:21:19: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:21:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Object> fReturnObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:22:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:22:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<num?> fReturnNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:23:17: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:23:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<int?> fReturnIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:24:17: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:24:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Null> fReturnNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:25:17: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:25:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Object> fBothObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:26:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:26:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<num?> fBothNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:27:15: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:27:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<int?> fBothIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:28:15: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:28:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Null> fBothNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:29:20: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:29:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Object> fNowhereObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:30:18: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:30:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<num?> fNowhereNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:31:18: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:31:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<int?> fNowhereIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:32:18: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:32:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Null> fNowhereNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:33:22: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:33:3: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object?> fArgumentObjectNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:34:22: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:34:3: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<dynamic> fArgumentDynamic; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:35:19: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:35:3: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<void> fArgumentVoid; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.modular.expect
index 717c859..0cbdeae 100644
--- a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.modular.expect
@@ -2,192 +2,192 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:13:13: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:13:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// A<Object> aObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:14:11: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:14:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num?> aNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:15:11: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:15:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<int?> aIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:16:11: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:16:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<Null> aNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:17:21: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:17:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object> fArgumentObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:18:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:18:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<num?> fArgumentNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:19:19: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:19:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<int?> fArgumentIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:20:19: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:20:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Null> fArgumentNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:21:19: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:21:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Object> fReturnObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:22:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:22:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<num?> fReturnNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:23:17: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:23:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<int?> fReturnIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:24:17: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:24:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Null> fReturnNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:25:17: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:25:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Object> fBothObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:26:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:26:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<num?> fBothNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:27:15: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:27:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<int?> fBothIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:28:15: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:28:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Null> fBothNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:29:20: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:29:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Object> fNowhereObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:30:18: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:30:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<num?> fNowhereNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:31:18: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:31:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<int?> fNowhereIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:32:18: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:32:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Null> fNowhereNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:33:22: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:33:3: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object?> fArgumentObjectNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:34:22: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:34:3: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<dynamic> fArgumentDynamic; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:35:19: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:35:3: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<void> fArgumentVoid; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.transformed.expect
index 717c859..0cbdeae 100644
--- a/pkg/front_end/testcases/nnbd/issue42429.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42429.dart.weak.transformed.expect
@@ -2,192 +2,192 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:13:13: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:13:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// A<Object> aObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:14:11: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:14:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<num?> aNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:15:11: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:15:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<int?> aIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:16:11: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:16:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// Try changing type arguments so that they conform to the bounds.
// A<Null> aNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<T extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:17:21: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:17:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object> fArgumentObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:18:19: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:18:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<num?> fArgumentNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:19:19: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:19:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<int?> fArgumentIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:20:19: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:20:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Null> fArgumentNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:21:19: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:21:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Object> fReturnObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:22:17: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:22:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<num?> fReturnNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:23:17: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:23:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<int?> fReturnIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:24:17: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:24:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FReturn'.
// Try changing type arguments so that they conform to the bounds.
// FReturn<Null> fReturnNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:8:17: Context: This is the type variable whose bound isn't conformed to.
// typedef FReturn<X extends num> = X Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:25:17: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:25:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Object> fBothObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:26:15: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:26:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<num?> fBothNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:27:15: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:27:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<int?> fBothIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:28:15: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:28:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FBoth'.
// Try changing type arguments so that they conform to the bounds.
// FBoth<Null> fBothNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:9:15: Context: This is the type variable whose bound isn't conformed to.
// typedef FBoth<X extends num> = X Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:29:20: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:29:3: Error: Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Object> fNowhereObject; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:30:18: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:30:3: Error: Type argument 'num?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<num?> fNowhereNumNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:31:18: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:31:3: Error: Type argument 'int?' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<int?> fNowhereIntNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:32:18: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:32:3: Error: Type argument 'Null' doesn't conform to the bound 'num' of the type variable 'X' on 'FNowhere'.
// Try changing type arguments so that they conform to the bounds.
// FNowhere<Null> fNowhereNull; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:10:18: Context: This is the type variable whose bound isn't conformed to.
// typedef FNowhere<X extends num> = Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:33:22: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:33:3: Error: Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// - 'Object' is from 'dart:core'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<Object?> fArgumentObjectNullable; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:34:22: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:34:3: Error: Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<dynamic> fArgumentDynamic; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
//
-// pkg/front_end/testcases/nnbd/issue42429.dart:35:19: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
+// pkg/front_end/testcases/nnbd/issue42429.dart:35:3: Error: Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FArgument'.
// Try changing type arguments so that they conform to the bounds.
// FArgument<void> fArgumentVoid; // Error.
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42429.dart:7:19: Context: This is the type variable whose bound isn't conformed to.
// typedef FArgument<X extends num> = Function(X);
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.strong.expect
index e263ad8..1495f43 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.strong.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.strong.transformed.expect
index e263ad8..1495f43 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.strong.transformed.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.expect
index e263ad8..1495f43 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.modular.expect
index e263ad8..1495f43 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.modular.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.outline.expect
index 46e4efc..ec07cf7 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.outline.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.transformed.expect
index e263ad8..1495f43 100644
--- a/pkg/front_end/testcases/nnbd/issue42434.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434.dart.weak.transformed.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434.dart:7:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434.dart:7:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.expect
index 88588f6..a478b42 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.transformed.expect
index 88588f6..a478b42 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.strong.transformed.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.expect
index 88588f6..a478b42 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.modular.expect
index 88588f6..a478b42 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.modular.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.outline.expect
index d314070..7167cc7 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.outline.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.transformed.expect
index 88588f6..a478b42 100644
--- a/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42434_2.dart.weak.transformed.expect
@@ -2,13 +2,13 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:21: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue42434_2.dart:5:41: Error: Type argument 'X/*1*/' doesn't conform to the bound 'B<X/*2*/>' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'B' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue42434_2.dart'.
// Try changing type arguments so that they conform to the bounds.
// typedef AAlias<X> = Function<X1 extends A<X>> ();
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue42434_2.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends B<X>> = Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.strong.expect
index 46f6782..c89209d 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.strong.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,158 +38,158 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:12:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:12:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:16:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:16:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:17:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:17:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:25:11: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:25:5: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:26:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:26:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:30:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:30:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:31:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:31:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:39:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:39:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:40:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:40:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:45:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:45:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? a;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:46:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:46:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.strong.transformed.expect
index 46f6782..c89209d 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.strong.transformed.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,158 +38,158 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:12:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:12:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:16:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:16:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:17:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:17:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:25:11: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:25:5: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:26:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:26:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:30:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:30:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:31:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:31:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:39:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:39:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:40:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:40:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:45:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:45:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? a;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:46:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:46:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.expect
index 46f6782..c89209d 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,158 +38,158 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:12:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:12:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:16:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:16:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:17:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:17:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:25:11: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:25:5: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:26:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:26:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:30:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:30:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:31:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:31:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:39:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:39:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:40:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:40:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:45:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:45:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? a;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:46:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:46:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.modular.expect
index 46f6782..c89209d 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.modular.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,158 +38,158 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:12:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:12:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:16:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:16:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:17:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:17:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:25:11: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:25:5: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:26:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:26:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:30:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:30:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:31:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:31:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:39:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:39:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:40:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:40:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:45:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:45:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? a;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:46:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:46:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.outline.expect
index ffca4b4..07d69b7 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.outline.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,65 +38,65 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.transformed.expect
index 46f6782..c89209d 100644
--- a/pkg/front_end/testcases/nnbd/issue43211.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue43211.dart.weak.transformed.expect
@@ -2,27 +2,27 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:10:53: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:10:41: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// void method1<Y extends A<Y>?>(A<Y> a, A<A<Null>>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:15:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:15:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
@@ -38,158 +38,158 @@
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:23:7: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A' in the supertype 'A' of class 'B'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:36: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:24:44: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
+// class A<X extends A<X>?> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:34: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:29:42: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// Try changing type arguments so that they conform to the bounds.
+// void method2<Y extends String>(D<Y> a, D<String>? b) {
+// ^
+// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
+// class D<X extends num> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/issue43211.dart:23:40: Error: Type argument 'X/*1*/' doesn't conform to the bound 'A<X/*2*/>?' of the type variable 'X' on 'A'.
// - 'X/*1*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// - 'X/*2*/' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// class B<X extends A<Null>?> implements A<X> {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:41: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:24:56: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// void method1<Y extends A<Null>?>(A<Y> a, A<A<Null>>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
-// class A<X extends A<X>?> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:39: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:29:53: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
-// Try changing type arguments so that they conform to the bounds.
-// void method2<Y extends String>(D<Y> a, D<String>? b) {
-// ^
-// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
-// class D<X extends num> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/issue43211.dart:36:34: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:36:22: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.redirect(A<A<Null>>? a) = C.internal;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:38:30: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:38:18: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// factory C.fact(A<A<Null>>? a) {
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:12:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:12:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:16:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:16:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:17:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:17:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:25:11: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:25:5: Error: Type argument 'Y' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:26:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:26:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:30:11: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:30:5: Error: Type argument 'Y' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<Y>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:31:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:31:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? d;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:39:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:39:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:40:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:40:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? c;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:45:17: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:45:5: Error: Type argument 'A<Null>' doesn't conform to the bound 'A<X>?' of the type variable 'X' on 'A'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/issue43211.dart'.
// Try changing type arguments so that they conform to the bounds.
// A<A<Null>>? a;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:5:9: Context: This is the type variable whose bound isn't conformed to.
// class A<X extends A<X>?> {}
// ^
//
-// pkg/front_end/testcases/nnbd/issue43211.dart:46:16: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
+// pkg/front_end/testcases/nnbd/issue43211.dart:46:5: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'X' on 'D'.
// Try changing type arguments so that they conform to the bounds.
// D<String>? b;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue43211.dart:7:9: Context: This is the type variable whose bound isn't conformed to.
// class D<X extends num> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.strong.expect
index d0065b3..4c7be00 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.strong.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.strong.transformed.expect
index d0065b3..4c7be00 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.strong.transformed.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.expect
index d0065b3..4c7be00 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.modular.expect
index d0065b3..4c7be00 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.modular.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.outline.expect
index 5fc32cd..2f4ff7f 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.outline.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.transformed.expect
index d0065b3..4c7be00 100644
--- a/pkg/front_end/testcases/nnbd/issue44455.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue44455.dart.weak.transformed.expect
@@ -2,18 +2,18 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:6:9: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:6:19: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F'.
// Try changing type arguments so that they conform to the bounds.
// class A<X extends F<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:5:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<Y extends num> = Y Function();
// ^
//
-// pkg/front_end/testcases/nnbd/issue44455.dart:8:10: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
+// pkg/front_end/testcases/nnbd/issue44455.dart:8:20: Error: Type argument 'X' doesn't conform to the bound 'num' of the type variable 'Y' on 'F2'.
// Try changing type arguments so that they conform to the bounds.
// class A2<X extends F2<X>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/issue44455.dart:9:12: Context: This is the type variable whose bound isn't conformed to.
// typedef F2<Y extends num> = Y Function();
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.expect
index 5537cc3..8b88b00 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.expect
@@ -18,455 +18,425 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar8 extends B<dynamic> {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo1(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo2<X extends F>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo5({required F x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo7([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// B<num> x;
-// ^
+// class Bar8 extends B<dynamic> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
+// F<A<dynamic>, A<Never>> x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// for (F x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo1(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo2<X extends F>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo5({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo7([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F? x]) {}
+// ^
//
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:72:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
@@ -476,50 +446,58 @@
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:20: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// B<num> x;
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:8: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// for (B<num> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar1(B<num> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// barBar2<X extends B<num>>() {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// barBar2<X extends B<num>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> barBar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:28: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:20: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.transformed.expect
index c007963..96f0d73 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.strong.transformed.expect
@@ -18,455 +18,425 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar8 extends B<dynamic> {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo1(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo2<X extends F>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo5({required F x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo7([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// B<num> x;
-// ^
+// class Bar8 extends B<dynamic> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
+// F<A<dynamic>, A<Never>> x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// for (F x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo1(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo2<X extends F>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo5({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo7([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F? x]) {}
+// ^
//
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:72:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
@@ -476,50 +446,58 @@
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:20: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// B<num> x;
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:8: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// for (B<num> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar1(B<num> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// barBar2<X extends B<num>>() {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// barBar2<X extends B<num>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> barBar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:28: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:20: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.expect
index 5537cc3..8b88b00 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.expect
@@ -18,455 +18,425 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar8 extends B<dynamic> {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo1(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo2<X extends F>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo5({required F x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo7([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// B<num> x;
-// ^
+// class Bar8 extends B<dynamic> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
+// F<A<dynamic>, A<Never>> x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// for (F x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo1(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo2<X extends F>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo5({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo7([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F? x]) {}
+// ^
//
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:72:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
@@ -476,50 +446,58 @@
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:20: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// B<num> x;
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:8: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// for (B<num> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar1(B<num> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// barBar2<X extends B<num>>() {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// barBar2<X extends B<num>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> barBar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:28: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:20: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.modular.expect
index 5537cc3..8b88b00 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.modular.expect
@@ -18,455 +18,425 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar8 extends B<dynamic> {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo1(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo2<X extends F>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo5({required F x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo7([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// B<num> x;
-// ^
+// class Bar8 extends B<dynamic> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
+// F<A<dynamic>, A<Never>> x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// for (F x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo1(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo2<X extends F>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo5({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo7([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F? x]) {}
+// ^
//
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:72:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
@@ -476,50 +446,58 @@
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:20: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// B<num> x;
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:8: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// for (B<num> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar1(B<num> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// barBar2<X extends B<num>>() {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// barBar2<X extends B<num>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> barBar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:28: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:20: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.outline.expect
index 155fe0cd..b4f6b22 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.outline.expect
@@ -18,212 +18,226 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// class Bar8 extends B<dynamic> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.transformed.expect
index c007963..96f0d73 100644
--- a/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/super_bounded_hint.dart.weak.transformed.expect
@@ -18,455 +18,425 @@
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:31: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1a(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo1b(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:9: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo1b(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:14:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2a<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// foo2b<X extends F>() {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:15:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// foo2b<X extends F>() {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:17:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
// class Foo3a<X extends F<A<dynamic>, A<Never>>> {}
-// ^
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:30: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> foo4a() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F foo4b() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F foo4b() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:41: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo5a({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:19: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:19:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// - 'Object' is from 'dart:core'.
-// foo5b({required F x}) {}
-// ^
+// class Foo3b<X extends F> {}
+// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:33: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7a([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// foo7b([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:11: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// foo7b([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:13: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// bar1(B<num> x) {}
-// ^
+// bar2<X extends B<num>>() {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:56:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:22: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// bar2<X extends B<num>>() {}
+// class Bar3<X extends B<num>> {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:11:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1a(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo1b(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:12:7: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo1b(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:21:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> foo4a() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F foo4b() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:22:1: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F foo4b() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:24:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5a({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo5b({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:25:17: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo5b({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:47:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7a([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// foo7b([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:48:8: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// foo7b([F? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:54:6: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// bar1(B<num> x) {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:58:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar3<X extends B<num>> {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:60:1: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> bar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:23: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:62:16: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:76:7: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// bar7([B<num>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the supertype 'B' of class 'Bar8'.
-// Try changing type arguments so that they conform to the bounds.
-// class Bar8 extends B<dynamic> {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:78:20: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:27: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:32: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:37: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F<A<dynamic>, A<Never>> x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:35: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F<A<dynamic>, A<Never>> x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:34: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:45: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:37: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F x;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:5: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F x;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:10: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (F x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:15: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// for (F x in []) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo1(F x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:13: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo1(F x) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo2<X extends F>() {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo2<X extends F>() {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F' in the return type.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try changing type arguments so that they conform to the bounds.
-// F fooFoo4() => throw 42;
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:12: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// F fooFoo4() => throw 42;
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo5({required F x}) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:23: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo5({required F x}) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// fooFoo7([F? x]) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
-// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:15: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
-// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
-// - 'Object' is from 'dart:core'.
-// fooFoo7([F? x]) {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:10: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// B<num> x;
-// ^
+// class Bar8 extends B<dynamic> {}
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:15: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
// Try changing type arguments so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
+// F<A<dynamic>, A<Never>> x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:28:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:29:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F<A<dynamic>, A<Never>> x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:30:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F<A<dynamic>, A<Never>> x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:31:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F<A<dynamic>, A<Never>>>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:32:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F<A<dynamic>, A<Never>> fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:33:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F<A<dynamic>, A<Never>> x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Error: Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try changing type arguments so that they conform to the bounds.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:34:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F<A<dynamic>, A<Never>>? x]) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F x;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:38:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F x;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// for (F x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:39:8: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// for (F x in []) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo1(F x) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:40:11: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo1(F x) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo2<X extends F>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:41:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo2<X extends F>() {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// F fooFoo4() => throw 42;
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:42:3: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// F fooFoo4() => throw 42;
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo5({required F x}) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:43:21: Context: If you want 'F<A<dynamic>, A<Never>>' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo5({required F x}) {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Error: Inferred type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'F'.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// fooFoo7([F? x]) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:9:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef F<X extends A<X>, Y extends A<Y>> = X Function(Y);
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:44:12: Context: If you want 'F<A<dynamic>, A<Never>>?' to be a super-bounded type, note that the inverted type 'F<A<Never>, A<Object?>>?' must then satisfy its bounds, which it does not.
+// - 'A' is from 'pkg/front_end/testcases/nnbd/super_bounded_hint.dart'.
+// - 'Object' is from 'dart:core'.
+// fooFoo7([F? x]) {}
+// ^
//
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:72:7: Error: Type argument 'dynamic' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
@@ -476,50 +446,58 @@
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:20: Error: Inferred type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try specifying type arguments explicitly so that they conform to the bounds.
-// for (B<num> x in []) {}
-// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:65:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// B<num> x;
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:18: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:66:8: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// for (B<num> x in []) {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:67:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar1(B<num> x) {}
-// ^
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
-// class B<X extends int> {}
-// ^
-//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:11: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
-// Try changing type arguments so that they conform to the bounds.
-// barBar2<X extends B<num>>() {}
// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:17: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B' in the return type.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:68:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// Try changing type arguments so that they conform to the bounds.
+// barBar2<X extends B<num>>() {}
+// ^
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
+// class B<X extends int> {}
+// ^
+//
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:69:3: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// B<num> barBar4() => throw 42;
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:28: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:70:21: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar5({required B<num> x}) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
//
-// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:20: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
+// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:71:12: Error: Type argument 'num' doesn't conform to the bound 'int' of the type variable 'X' on 'B'.
// Try changing type arguments so that they conform to the bounds.
// barBar7([B<num>? x]) {}
-// ^
+// ^
// pkg/front_end/testcases/nnbd/super_bounded_hint.dart:52:9: Context: This is the type variable whose bound isn't conformed to.
// class B<X extends int> {}
// ^
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart
new file mode 100644
index 0000000..cb14757
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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.
+
+// @dart=2.9
+
+import 'main_lib1.dart';
+import 'main_lib2.dart';
+
+method1(Class1 c1a, List<Class1> c1b, Class2 c2a, List<Class2> c2b) {}
+method2(Typedef1 t1a, List<Typedef1> t1b, Typedef2 t2a, List<Typedef2> t2b) {}
+
+main() {}
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline.expect
new file mode 100644
index 0000000..5353363
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline.expect
@@ -0,0 +1,7 @@
+// @dart = 2.9
+import 'main_lib1.dart';
+import 'main_lib2.dart';
+
+method1(Class1 c1a, List<Class1> c1b, Class2 c2a, List<Class2> c2b) {}
+method2(Typedef1 t1a, List<Typedef1> t1b, Typedef2 t2a, List<Typedef2> t2b) {}
+main() {}
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..914bd7f
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.textual_outline_modelled.expect
@@ -0,0 +1,7 @@
+// @dart = 2.9
+import 'main_lib1.dart';
+import 'main_lib2.dart';
+
+main() {}
+method1(Class1 c1a, List<Class1> c1b, Class2 c2a, List<Class2> c2b) {}
+method2(Typedef1 t1a, List<Typedef1> t1b, Typedef2 t2a, List<Typedef2> t2b) {}
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.expect
new file mode 100644
index 0000000..52f6f7f
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.expect
@@ -0,0 +1,38 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+import "org-dartlang-testcase:///main_lib2.dart";
+
+static method method1(mai::Class1<core::Object>* c1a, core::List<mai::Class1<core::Object>*>* c1b, mai2::Class2<core::Object>* c2a, core::List<mai2::Class2<core::Object>*>* c2b) → dynamic {}
+static method method2(mai::Class1<core::int*>* t1a, core::List<mai::Class1<core::int*>*>* t1b, mai2::Class2<core::int*>* t2a, core::List<mai2::Class2<core::int*>*>* t2b) → dynamic {}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef Typedef1<T extends core::int> = mai::Class1<T>;
+class Class1<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai::Class1<mai::Class1::T>
+ : super core::Object::•()
+ ;
+}
+static method _#Typedef1#new#tearOff<T extends core::int>() → mai::Class1<mai::_#Typedef1#new#tearOff::T>
+ return new mai::Class1::•<mai::_#Typedef1#new#tearOff::T>();
+
+library /*isNonNullableByDefault*/;
+import self as mai2;
+import "dart:core" as core;
+
+typedef Typedef2<T extends core::int> = mai2::Class2<T>;
+class Class2<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai2::Class2<mai2::Class2::T>
+ : super core::Object::•()
+ ;
+}
+static method _#Typedef2#new#tearOff<T extends core::int>() → mai2::Class2<mai2::_#Typedef2#new#tearOff::T>
+ return new mai2::Class2::•<mai2::_#Typedef2#new#tearOff::T>();
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.modular.expect
new file mode 100644
index 0000000..8313d94
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.modular.expect
@@ -0,0 +1,25 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+import "org-dartlang-testcase:///main_lib2.dart";
+
+static method method1(mai::Class1<core::Object>* c1a, core::List<mai::Class1<core::Object>*>* c1b, mai2::Class2<core::Object>* c2a, core::List<mai2::Class2<core::Object>*>* c2b) → dynamic {}
+static method method2(mai::Class1<core::int*>* t1a, core::List<mai::Class1<core::int*>*>* t1b, mai2::Class2<core::int*>* t2a, core::List<mai2::Class2<core::int*>*>* t2b) → dynamic {}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef Typedef1<T extends core::int> = mai::Class1<T>;
+class Class1<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai::Class1<mai::Class1::T>
+ : super core::Object::•()
+ ;
+}
+static method _#Typedef1#new#tearOff<T extends core::int>() → mai::Class1<mai::_#Typedef1#new#tearOff::T>
+ return new mai::Class1::•<mai::_#Typedef1#new#tearOff::T>();
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.outline.expect
new file mode 100644
index 0000000..357068b
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.outline.expect
@@ -0,0 +1,39 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+import "org-dartlang-testcase:///main_lib2.dart";
+
+static method method1(mai::Class1<core::Object>* c1a, core::List<mai::Class1<core::Object>*>* c1b, mai2::Class2<core::Object>* c2a, core::List<mai2::Class2<core::Object>*>* c2b) → dynamic
+ ;
+static method method2(mai::Class1<core::int*>* t1a, core::List<mai::Class1<core::int*>*>* t1b, mai2::Class2<core::int*>* t2a, core::List<mai2::Class2<core::int*>*>* t2b) → dynamic
+ ;
+static method main() → dynamic
+ ;
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef Typedef1<T extends core::int> = mai::Class1<T>;
+class Class1<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai::Class1<mai::Class1::T>
+ ;
+}
+static method _#Typedef1#new#tearOff<T extends core::int>() → mai::Class1<mai::_#Typedef1#new#tearOff::T>
+ return new mai::Class1::•<mai::_#Typedef1#new#tearOff::T>();
+
+library /*isNonNullableByDefault*/;
+import self as mai2;
+import "dart:core" as core;
+
+typedef Typedef2<T extends core::int> = mai2::Class2<T>;
+class Class2<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai2::Class2<mai2::Class2::T>
+ ;
+}
+static method _#Typedef2#new#tearOff<T extends core::int>() → mai2::Class2<mai2::_#Typedef2#new#tearOff::T>
+ return new mai2::Class2::•<mai2::_#Typedef2#new#tearOff::T>();
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.transformed.expect
new file mode 100644
index 0000000..52f6f7f
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main.dart.weak.transformed.expect
@@ -0,0 +1,38 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+import "org-dartlang-testcase:///main_lib2.dart";
+
+static method method1(mai::Class1<core::Object>* c1a, core::List<mai::Class1<core::Object>*>* c1b, mai2::Class2<core::Object>* c2a, core::List<mai2::Class2<core::Object>*>* c2b) → dynamic {}
+static method method2(mai::Class1<core::int*>* t1a, core::List<mai::Class1<core::int*>*>* t1b, mai2::Class2<core::int*>* t2a, core::List<mai2::Class2<core::int*>*>* t2b) → dynamic {}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef Typedef1<T extends core::int> = mai::Class1<T>;
+class Class1<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai::Class1<mai::Class1::T>
+ : super core::Object::•()
+ ;
+}
+static method _#Typedef1#new#tearOff<T extends core::int>() → mai::Class1<mai::_#Typedef1#new#tearOff::T>
+ return new mai::Class1::•<mai::_#Typedef1#new#tearOff::T>();
+
+library /*isNonNullableByDefault*/;
+import self as mai2;
+import "dart:core" as core;
+
+typedef Typedef2<T extends core::int> = mai2::Class2<T>;
+class Class2<T extends core::Object> extends core::Object {
+ synthetic constructor •() → mai2::Class2<mai2::Class2::T>
+ : super core::Object::•()
+ ;
+}
+static method _#Typedef2#new#tearOff<T extends core::int>() → mai2::Class2<mai2::_#Typedef2#new#tearOff::T>
+ return new mai2::Class2::•<mai2::_#Typedef2#new#tearOff::T>();
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib1.dart b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib1.dart
new file mode 100644
index 0000000..56b8028
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib1.dart
@@ -0,0 +1,7 @@
+// Copyright (c) 2022, 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.
+
+class Class1<T extends Object> {}
+
+typedef Typedef1<T extends int> = Class1<T>;
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib2.dart b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib2.dart
new file mode 100644
index 0000000..6ec94dd
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/main_lib2.dart
@@ -0,0 +1,7 @@
+// Copyright (c) 2022, 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.
+
+class Class2<T extends Object> {}
+
+typedef Typedef2<T extends int> = Class2<T>;
diff --git a/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/test.options b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/test.options
new file mode 100644
index 0000000..8400751
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/default_type_from_opt_in/test.options
@@ -0,0 +1 @@
+main_lib2.dart
\ No newline at end of file
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.expect
index 6bf247e..6ff4604 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.modular.expect
index 864208b..9067a8a 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.modular.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.outline.expect
index 7f83539..8bb74bf 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.outline.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.transformed.expect
index 2a72e6a..336a50e 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.dart.weak.transformed.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.expect
index 6bf247e..6ff4604 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.modular.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.modular.expect
index 6bf247e..6ff4604 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.modular.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.outline.expect
index 7f83539..8bb74bf 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.outline.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.transformed.expect
index 2a72e6a..336a50e 100644
--- a/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/super_access/main.no_link.dart.weak.transformed.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
import "main_lib1.dart" as mai;
-import "main_lib2.dart" as mai2;
import "org-dartlang-testcase:///main_lib1.dart";
import "org-dartlang-testcase:///main_lib2.dart";
diff --git a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.expect b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.expect
index 1722631..929831e 100644
--- a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.expect
+++ b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.expect
@@ -2,7 +2,7 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'C<dynamic> Function(C<dynamic>)' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'G<C<dynamic>>' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// A a = throw 42; // Error.
@@ -10,11 +10,23 @@
// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends G<C<X>>> = C<X>;
// ^
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<C<dynamic> Function(C<dynamic>)>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<G<C<dynamic>>>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// A a = throw 42; // Error.
// ^
//
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Error: Inferred type argument 'H<dynamic>' doesn't conform to the bound 'C<X Function(X)>' of the type variable 'X' on 'B'.
+// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// B b = throw 42; // Error.
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:10:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef B<X extends H<X>> = C<X>;
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Context: If you want 'B<H<dynamic>>' to be a super-bounded type, note that the inverted type 'B<H<Never>>' must then satisfy its bounds, which it does not.
+// B b = throw 42; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.transformed.expect b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.transformed.expect
index 1722631..929831e 100644
--- a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.strong.transformed.expect
@@ -2,7 +2,7 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'C<dynamic> Function(C<dynamic>)' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'G<C<dynamic>>' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// A a = throw 42; // Error.
@@ -10,11 +10,23 @@
// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends G<C<X>>> = C<X>;
// ^
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<C<dynamic> Function(C<dynamic>)>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<G<C<dynamic>>>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// A a = throw 42; // Error.
// ^
//
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Error: Inferred type argument 'H<dynamic>' doesn't conform to the bound 'C<X Function(X)>' of the type variable 'X' on 'B'.
+// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// B b = throw 42; // Error.
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:10:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef B<X extends H<X>> = C<X>;
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Context: If you want 'B<H<dynamic>>' to be a super-bounded type, note that the inverted type 'B<H<Never>>' must then satisfy its bounds, which it does not.
+// B b = throw 42; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.expect b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.expect
index 1722631..929831e 100644
--- a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.expect
+++ b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.expect
@@ -2,7 +2,7 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'C<dynamic> Function(C<dynamic>)' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'G<C<dynamic>>' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// A a = throw 42; // Error.
@@ -10,11 +10,23 @@
// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends G<C<X>>> = C<X>;
// ^
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<C<dynamic> Function(C<dynamic>)>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<G<C<dynamic>>>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// A a = throw 42; // Error.
// ^
//
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Error: Inferred type argument 'H<dynamic>' doesn't conform to the bound 'C<X Function(X)>' of the type variable 'X' on 'B'.
+// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// B b = throw 42; // Error.
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:10:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef B<X extends H<X>> = C<X>;
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Context: If you want 'B<H<dynamic>>' to be a super-bounded type, note that the inverted type 'B<H<Never>>' must then satisfy its bounds, which it does not.
+// B b = throw 42; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.modular.expect b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.modular.expect
index 1722631..929831e 100644
--- a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.modular.expect
@@ -2,7 +2,7 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'C<dynamic> Function(C<dynamic>)' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'G<C<dynamic>>' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// A a = throw 42; // Error.
@@ -10,11 +10,23 @@
// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends G<C<X>>> = C<X>;
// ^
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<C<dynamic> Function(C<dynamic>)>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<G<C<dynamic>>>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// A a = throw 42; // Error.
// ^
//
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Error: Inferred type argument 'H<dynamic>' doesn't conform to the bound 'C<X Function(X)>' of the type variable 'X' on 'B'.
+// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// B b = throw 42; // Error.
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:10:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef B<X extends H<X>> = C<X>;
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Context: If you want 'B<H<dynamic>>' to be a super-bounded type, note that the inverted type 'B<H<Never>>' must then satisfy its bounds, which it does not.
+// B b = throw 42; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.transformed.expect b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.transformed.expect
index 1722631..929831e 100644
--- a/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart.weak.transformed.expect
@@ -2,7 +2,7 @@
//
// Problems in library:
//
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'C<dynamic> Function(C<dynamic>)' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Error: Inferred type argument 'G<C<dynamic>>' doesn't conform to the bound 'C<X> Function(C<X>)' of the type variable 'X' on 'A'.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// Try specifying type arguments explicitly so that they conform to the bounds.
// A a = throw 42; // Error.
@@ -10,11 +10,23 @@
// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:7:11: Context: This is the type variable whose bound isn't conformed to.
// typedef A<X extends G<C<X>>> = C<X>;
// ^
-// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<C<dynamic> Function(C<dynamic>)>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:13:3: Context: If you want 'A<G<C<dynamic>>>' to be a super-bounded type, note that the inverted type 'A<G<C<Never>>>' must then satisfy its bounds, which it does not.
// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
// A a = throw 42; // Error.
// ^
//
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Error: Inferred type argument 'H<dynamic>' doesn't conform to the bound 'C<X Function(X)>' of the type variable 'X' on 'B'.
+// - 'C' is from 'pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart'.
+// Try specifying type arguments explicitly so that they conform to the bounds.
+// B b = throw 42; // Error.
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:10:11: Context: This is the type variable whose bound isn't conformed to.
+// typedef B<X extends H<X>> = C<X>;
+// ^
+// pkg/front_end/testcases/nonfunction_type_aliases/issue45519.dart:14:3: Context: If you want 'B<H<dynamic>>' to be a super-bounded type, note that the inverted type 'B<H<Never>>' must then satisfy its bounds, which it does not.
+// B b = throw 42; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
diff --git a/pkg/front_end/testcases/outline.status b/pkg/front_end/testcases/outline.status
index a5ff68d..4e24ada 100644
--- a/pkg/front_end/testcases/outline.status
+++ b/pkg/front_end/testcases/outline.status
@@ -18,6 +18,7 @@
extension_types/simple_show_hide: ExpectationFileMismatchSerialized # Expected.
extension_types/type_variable_in_static_context: ExpectationFileMismatchSerialized # Expected.
general/abstract_members: TypeCheckError
+general/bounds_type_parameters: TypeCheckError
general/bug30695: TypeCheckError
general/covariant_field: TypeCheckError
general/crashes/crash_02/main: Crash
diff --git a/pkg/front_end/testcases/text_serialization.status b/pkg/front_end/testcases/text_serialization.status
index 2a12a528..4025cef 100644
--- a/pkg/front_end/testcases/text_serialization.status
+++ b/pkg/front_end/testcases/text_serialization.status
@@ -34,6 +34,7 @@
general/ambiguous_exports: RuntimeError
general/await_in_non_async: RuntimeError
general/bounded_implicit_instantiation: TypeCheckError
+general/bounds_instances: TypeCheckError
general/bug30695: TypeCheckError
general/bug31124: RuntimeError
general/call: RuntimeError
diff --git a/pkg/front_end/testcases/weak.status b/pkg/front_end/testcases/weak.status
index 68ae6c1..50e8f90 100644
--- a/pkg/front_end/testcases/weak.status
+++ b/pkg/front_end/testcases/weak.status
@@ -124,6 +124,7 @@
general/ambiguous_exports: RuntimeError # Expected, this file exports two main methods.
general/await_in_non_async: RuntimeError # Expected.
general/bounded_implicit_instantiation: TypeCheckError
+general/bounds_instances: TypeCheckError
general/bug30695: TypeCheckError
general/bug31124: RuntimeError # Test has no main method (and we shouldn't add one).
general/call: RuntimeError
diff --git a/pkg/front_end/tool/ast_model.dart b/pkg/front_end/tool/ast_model.dart
index 9979dcb..4ae1aee 100644
--- a/pkg/front_end/tool/ast_model.dart
+++ b/pkg/front_end/tool/ast_model.dart
@@ -174,7 +174,6 @@
},
'FunctionType': {
'typeParameters': FieldRule(isDeclaration: true),
- '_typedefType': FieldRule(name: 'typedefType'),
},
'TypeParameterType': {
'parameter': FieldRule(isDeclaration: false),
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index c962060..4499a08 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
type ComponentFile {
UInt32 magic = 0x90ABCDEF;
- UInt32 formatVersion = 79;
+ UInt32 formatVersion = 80;
Byte[10] shortSdkHash;
List<String> problemsAsJson; // Described in problems.md.
Library[] libraries;
@@ -1463,7 +1463,6 @@
UInt totalParameterCount;
List<DartType> positionalParameters;
List<NamedDartType> namedParameters;
- Option<TypedefType> typedef;
DartType returnType;
}
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index f3f7728..78972bc 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -8752,8 +8752,7 @@
type.positionalParameters, type.returnType, type.declaredNullability,
namedParameters: type.namedParameters,
typeParameters: freshTypeParameters.freshTypeParameters,
- requiredParameterCount: type.requiredParameterCount,
- typedefType: null);
+ requiredParameterCount: type.requiredParameterCount);
}
@override
@@ -11207,8 +11206,6 @@
@override
final Nullability declaredNullability;
- TypedefType? _typedefType;
-
final DartType returnType;
@override
@@ -11218,27 +11215,10 @@
this.declaredNullability,
{this.namedParameters: const <NamedType>[],
this.typeParameters: const <TypeParameter>[],
- int? requiredParameterCount,
- TypedefType? typedefType})
+ int? requiredParameterCount})
: this.positionalParameters = positionalParameters,
this.requiredParameterCount =
- requiredParameterCount ?? positionalParameters.length,
- _typedefType = typedefType;
-
- Reference? get typedefReference => _typedefType?.typedefReference;
-
- Typedef? get typedef => typedefReference?.asTypedef;
-
- /// The [Typedef] this function type is created for, if any.
- TypedefType? get typedefType => _typedefType;
-
- void set typedefType(TypedefType? value) {
- assert(
- _typedefType == null,
- "Cannot change an already set FunctionType.typedefType from "
- "$_typedefType to $value.");
- _typedefType = value;
- }
+ requiredParameterCount ?? positionalParameters.length;
@override
Nullability get nullability => declaredNullability;
@@ -11255,7 +11235,6 @@
visitList(typeParameters, v);
visitList(positionalParameters, v);
visitList(namedParameters, v);
- typedefType?.accept(v);
returnType.accept(v);
}
@@ -11325,8 +11304,7 @@
if (typeParameters.isEmpty) return this;
return new FunctionType(positionalParameters, returnType, nullability,
requiredParameterCount: requiredParameterCount,
- namedParameters: namedParameters,
- typedefType: null);
+ namedParameters: namedParameters);
}
/// Looks up the type of the named parameter with the given name.
@@ -11375,8 +11353,7 @@
positionalParameters, returnType, declaredNullability,
namedParameters: namedParameters,
typeParameters: typeParameters,
- requiredParameterCount: requiredParameterCount,
- typedefType: typedefType?.withDeclaredNullability(declaredNullability));
+ requiredParameterCount: requiredParameterCount);
if (typeParameters.isEmpty) return result;
return getFreshTypeParameters(typeParameters).applyToFunctionType(result);
}
@@ -13485,8 +13462,7 @@
type.positionalParameters, type.returnType, type.declaredNullability,
namedParameters: type.namedParameters,
typeParameters: freshTypeParameters.freshTypeParameters,
- requiredParameterCount: type.requiredParameterCount,
- typedefType: null);
+ requiredParameterCount: type.requiredParameterCount);
}
}
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index bc9a385..9df6792 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -3089,7 +3089,6 @@
int totalParameterCount = readUInt30();
List<DartType> positional = readDartTypeList();
List<NamedType> named = readNamedTypeList();
- TypedefType? typedefType = readDartTypeOption() as TypedefType?;
assert(positional.length + named.length == totalParameterCount);
DartType returnType = readDartType();
typeParameterStack.length = typeParameterStackHeight;
@@ -3097,8 +3096,7 @@
positional, returnType, Nullability.values[nullabilityIndex],
typeParameters: typeParameters,
requiredParameterCount: requiredParameterCount,
- namedParameters: named,
- typedefType: typedefType);
+ namedParameters: named);
}
DartType _readSimpleFunctionType() {
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index 3d18bb1..1f678e9 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -2390,8 +2390,7 @@
void visitFunctionType(FunctionType node) {
if (node.requiredParameterCount == node.positionalParameters.length &&
node.typeParameters.isEmpty &&
- node.namedParameters.isEmpty &&
- node.typedefType == null) {
+ node.namedParameters.isEmpty) {
writeByte(Tag.SimpleFunctionType);
writeByte(node.nullability.index);
writeNodeList(node.positionalParameters);
@@ -2406,7 +2405,6 @@
node.positionalParameters.length + node.namedParameters.length);
writeNodeList(node.positionalParameters);
writeNodeList(node.namedParameters);
- writeOptionalNode(node.typedefType);
writeNode(node.returnType);
leaveScope(typeParameters: node.typeParameters);
}
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index f589ea5..aed4155 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -176,7 +176,7 @@
/// Internal version of kernel binary format.
/// Bump it when making incompatible changes in kernel binaries.
/// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
- static const int BinaryFormatVersion = 79;
+ static const int BinaryFormatVersion = 80;
}
abstract class ConstantTag {
diff --git a/pkg/kernel/lib/src/bounds_checks.dart b/pkg/kernel/lib/src/bounds_checks.dart
index e40aca5..884fe9d 100644
--- a/pkg/kernel/lib/src/bounds_checks.dart
+++ b/pkg/kernel/lib/src/bounds_checks.dart
@@ -284,16 +284,16 @@
}
}
-// Finds type arguments that don't follow the rules of well-boundness.
+// Finds type arguments that don't follow the rules of well-boundedness.
//
// [bottomType] should be either Null or Never, depending on what should be
// taken for the bottom type at the call site. The bottom type is used in the
-// checks for super-boundness for construction of the auxiliary type. For
+// checks for super-boundedness for construction of the auxiliary type. For
// details see Dart Language Specification, Section 14.3.2 The Instantiation to
// Bound Algorithm.
List<TypeArgumentIssue> findTypeArgumentIssues(DartType type,
TypeEnvironment typeEnvironment, SubtypeCheckMode subtypeCheckMode,
- {bool allowSuperBounded = false,
+ {required bool allowSuperBounded,
required bool isNonNullableByDefault,
required bool areGenericArgumentsAllowed}) {
// ignore: unnecessary_null_comparison
@@ -305,26 +305,6 @@
List<DartType> arguments = const <DartType>[];
List<TypeArgumentIssue> typedefRhsResult = const <TypeArgumentIssue>[];
- if (type is FunctionType && type.typedefType != null) {
- // [type] is a function type that is an application of a parametrized
- // typedef. We need to check both the l.h.s. and the r.h.s. of the
- // definition in that case. For details, see [link]
- // (https://github.com/dart-lang/sdk/blob/master/docs/language/informal/super-bounded-types.md).
- FunctionType functionType = type;
- FunctionType cloned = new FunctionType(functionType.positionalParameters,
- functionType.returnType, functionType.nullability,
- namedParameters: functionType.namedParameters,
- typeParameters: functionType.typeParameters,
- requiredParameterCount: functionType.requiredParameterCount,
- typedefType: null);
- typedefRhsResult = findTypeArgumentIssues(
- cloned, typeEnvironment, subtypeCheckMode,
- allowSuperBounded: true,
- isNonNullableByDefault: isNonNullableByDefault,
- areGenericArgumentsAllowed: areGenericArgumentsAllowed);
- type = functionType.typedefType!;
- }
-
if (type is InterfaceType) {
variables = type.classNode.typeParameters;
arguments = type.typeArguments;
@@ -334,14 +314,6 @@
} else if (type is FunctionType) {
List<TypeArgumentIssue> result = <TypeArgumentIssue>[];
- for (TypeParameter parameter in type.typeParameters) {
- result.addAll(findTypeArgumentIssues(
- parameter.bound, typeEnvironment, subtypeCheckMode,
- allowSuperBounded: true,
- isNonNullableByDefault: isNonNullableByDefault,
- areGenericArgumentsAllowed: areGenericArgumentsAllowed));
- }
-
for (DartType formal in type.positionalParameters) {
result.addAll(findTypeArgumentIssues(
formal, typeEnvironment, subtypeCheckMode,
@@ -401,12 +373,6 @@
// The bound is InvalidType so it's not checked, because an error was
// reported already at the time of the creation of InvalidType.
}
-
- argumentsResult.addAll(findTypeArgumentIssues(
- argument, typeEnvironment, subtypeCheckMode,
- allowSuperBounded: true,
- isNonNullableByDefault: isNonNullableByDefault,
- areGenericArgumentsAllowed: areGenericArgumentsAllowed));
}
result.addAll(argumentsResult);
result.addAll(typedefRhsResult);
@@ -440,6 +406,8 @@
new Map<TypeParameter, DartType>.fromIterables(variables, arguments);
for (int i = 0; i < arguments.length; ++i) {
DartType argument = arguments[i];
+ // TODO(johnniwinther): Should we check this even when generic functions
+ // as type arguments is allowed?
if (isGenericFunctionTypeOrAlias(argument)) {
// Generic function types aren't allowed as type arguments either.
isCorrectSuperBounded = false;
@@ -517,12 +485,6 @@
result.add(new TypeArgumentIssue(i, argument, parameters[i], null));
}
}
-
- result.addAll(findTypeArgumentIssues(
- argument, typeEnvironment, subtypeCheckMode,
- allowSuperBounded: true,
- isNonNullableByDefault: isNonNullableByDefault,
- areGenericArgumentsAllowed: areGenericArgumentsAllowed));
}
return result;
}
@@ -554,6 +516,7 @@
class _SuperBoundedTypeInverter extends ReplacementVisitor {
final TypeEnvironment typeEnvironment;
final bool isNonNullableByDefault;
+ bool isOutermost = true;
_SuperBoundedTypeInverter(this.typeEnvironment,
{required this.isNonNullableByDefault})
@@ -629,6 +592,7 @@
@override
DartType? visitInterfaceType(InterfaceType node, int variance) {
+ isOutermost = false;
// Check for Object-based top types.
if (isTop(node) && flipTop(variance)) {
return bottomType;
@@ -639,6 +603,7 @@
@override
DartType? visitFutureOrType(FutureOrType node, int variance) {
+ isOutermost = false;
// Check FutureOr-based top types.
if (isTop(node) && flipTop(variance)) {
return bottomType;
@@ -679,10 +644,12 @@
// TypedefTypes receive special treatment because the variance of their
// arguments' positions depend on the opt-in status of the library.
- // TODO(cstefantsova): Remove the method when the discrepancy between the
- // NNBD modes is resolved.
@override
DartType? visitTypedefType(TypedefType node, int variance) {
+ if (!isNonNullableByDefault && !isOutermost) {
+ return node.unalias.accept1(this, variance);
+ }
+ isOutermost = false;
Nullability? newNullability = visitNullability(node);
List<DartType>? newTypeArguments = null;
for (int i = 0; i < node.typeArguments.length; i++) {
@@ -706,13 +673,8 @@
@override
DartType? visitFunctionType(FunctionType node, int variance) {
- // The variance of the Typedef parameters should be taken into account only
- // when for the NNBD code.
- if (node.typedefType != null && isNonNullableByDefault) {
- return node.typedefType!.accept1(this, variance);
- } else {
- return super.visitFunctionType(node, variance);
- }
+ isOutermost = false;
+ return super.visitFunctionType(node, variance);
}
}
@@ -887,3 +849,49 @@
if (type is TypedefType) type = type.unalias;
return type is FunctionType && type.typeParameters.isNotEmpty;
}
+
+bool hasGenericFunctionTypeAsTypeArgument(DartType type) {
+ return type.accept1(
+ const _HasGenericFunctionTypeAsTypeArgumentVisitor(), false);
+}
+
+class _HasGenericFunctionTypeAsTypeArgumentVisitor
+ extends DartTypeVisitor1<bool, bool> {
+ const _HasGenericFunctionTypeAsTypeArgumentVisitor();
+
+ @override
+ bool defaultDartType(DartType node, bool isTypeArgument) => false;
+
+ @override
+ bool visitFunctionType(FunctionType node, bool isTypeArgument) {
+ if (isTypeArgument && node.typeParameters.isNotEmpty) {
+ return true;
+ }
+ // TODO(johnniwinther): Should deeply nested generic function types be
+ // disallowed?
+ if (node.returnType.accept1(this, false)) return true;
+ for (DartType parameterType in node.positionalParameters) {
+ if (parameterType.accept1(this, false)) return true;
+ }
+ for (NamedType namedParameterType in node.namedParameters) {
+ if (namedParameterType.type.accept1(this, false)) return true;
+ }
+ return false;
+ }
+
+ @override
+ bool visitInterfaceType(InterfaceType node, bool isTypeArgument) {
+ for (DartType typeArgument in node.typeArguments) {
+ if (typeArgument.accept1(this, true)) return true;
+ }
+ return false;
+ }
+
+ @override
+ bool visitTypedefType(TypedefType node, bool isTypeArgument) {
+ for (DartType typeArgument in node.typeArguments) {
+ if (typeArgument.accept1(this, true)) return true;
+ }
+ return false;
+ }
+}
diff --git a/pkg/kernel/lib/src/dart_type_equivalence.dart b/pkg/kernel/lib/src/dart_type_equivalence.dart
index aeea30f..18a2081 100644
--- a/pkg/kernel/lib/src/dart_type_equivalence.dart
+++ b/pkg/kernel/lib/src/dart_type_equivalence.dart
@@ -44,47 +44,6 @@
return false;
}
- // If the two types are un-aliased typedef instantiations, check that
- // those instantiations are equal as well.
- bool nodeIsUnaliased = node.typedefType != null;
- bool otherIsUnaliased = other.typedefType != null;
- if (nodeIsUnaliased != otherIsUnaliased) {
- return false;
- }
- if (node.typedefType != null) {
- // The assert below checks the implication: if the typedef types are
- // equal, their un-aliased types are equal as well. The reverse is not
- // true due to possibly unused type parameters F<int> and F<String> may
- // be equal when un-aliased if the type parameter of typedef F isn't
- // used on the right-hand side of the definition of F. The checked
- // proposition in the assert allows to skip checking the function types
- // themselves if the typedef types are equal.
- assert(() {
- DartTypeEquivalence copy = this.copy();
- if (!copy.areEqual(node.typedefType!, other.typedefType!)) {
- return true;
- }
- FunctionType nodeWithoutTypedefType = new FunctionType(
- node.positionalParameters,
- node.returnType,
- node.declaredNullability,
- namedParameters: node.namedParameters,
- typeParameters: node.typeParameters,
- requiredParameterCount: node.requiredParameterCount,
- typedefType: null);
- FunctionType otherWithoutTypedefType = new FunctionType(
- other.positionalParameters,
- other.returnType,
- other.declaredNullability,
- namedParameters: other.namedParameters,
- typeParameters: other.typeParameters,
- requiredParameterCount: other.requiredParameterCount,
- typedefType: null);
- return copy.areEqual(nodeWithoutTypedefType, otherWithoutTypedefType);
- }());
- return node.typedefType!.accept1(this, other.typedefType);
- }
-
// Perform simple number checks before the checks on parts.
if (node.typeParameters.length != other.typeParameters.length) {
return false;
diff --git a/pkg/kernel/lib/src/equivalence.dart b/pkg/kernel/lib/src/equivalence.dart
index 3f11abc..840f85b 100644
--- a/pkg/kernel/lib/src/equivalence.dart
+++ b/pkg/kernel/lib/src/equivalence.dart
@@ -4074,9 +4074,6 @@
if (!checkFunctionType_declaredNullability(visitor, node, other)) {
result = visitor.resultOnInequivalence;
}
- if (!checkFunctionType_typedefType(visitor, node, other)) {
- result = visitor.resultOnInequivalence;
- }
if (!checkFunctionType_returnType(visitor, node, other)) {
result = visitor.resultOnInequivalence;
}
@@ -7122,12 +7119,6 @@
other.declaredNullability, 'declaredNullability');
}
- bool checkFunctionType_typedefType(
- EquivalenceVisitor visitor, FunctionType node, FunctionType other) {
- return visitor.checkNodes(
- node.typedefType, other.typedefType, 'typedefType');
- }
-
bool checkFunctionType_returnType(
EquivalenceVisitor visitor, FunctionType node, FunctionType other) {
return visitor.checkNodes(node.returnType, other.returnType, 'returnType');
diff --git a/pkg/kernel/lib/src/merge_visitor.dart b/pkg/kernel/lib/src/merge_visitor.dart
index fe27f5c..58e18fa 100644
--- a/pkg/kernel/lib/src/merge_visitor.dart
+++ b/pkg/kernel/lib/src/merge_visitor.dart
@@ -116,19 +116,10 @@
}
newNamedParameters[i] = newNamedType;
}
- TypedefType? newTypedefType;
- if (a.typedefType != null && b.typedefType != null) {
- newTypedefType =
- mergeTypes(a.typedefType!, b.typedefType!) as TypedefType?;
- // If the typedef couldn't be merged we just omit it from the resulting
- // function type since the typedef type is only informational.
- }
-
return new FunctionType(newPositionalParameters, newReturnType, nullability,
namedParameters: newNamedParameters,
typeParameters: newTypeParameters,
- requiredParameterCount: a.requiredParameterCount,
- typedefType: newTypedefType);
+ requiredParameterCount: a.requiredParameterCount);
}
NamedType? mergeNamedTypes(NamedType a, NamedType b, DartType newType) {
diff --git a/pkg/kernel/lib/src/replacement_visitor.dart b/pkg/kernel/lib/src/replacement_visitor.dart
index 2f625b4..5a60355 100644
--- a/pkg/kernel/lib/src/replacement_visitor.dart
+++ b/pkg/kernel/lib/src/replacement_visitor.dart
@@ -83,17 +83,9 @@
newNamedParameters[i] = newNamedType;
}
}
- TypedefType? newTypedefType =
- visitType(node.typedefType, variance) as TypedefType?;
- return createFunctionType(
- node,
- newNullability,
- newTypeParameters,
- newReturnType,
- newPositionalParameters,
- newNamedParameters,
- newTypedefType);
+ return createFunctionType(node, newNullability, newTypeParameters,
+ newReturnType, newPositionalParameters, newNamedParameters);
}
NamedType? createNamedType(NamedType node, DartType? newType) {
@@ -110,13 +102,11 @@
List<TypeParameter>? newTypeParameters,
DartType? newReturnType,
List<DartType>? newPositionalParameters,
- List<NamedType>? newNamedParameters,
- TypedefType? newTypedefType) {
+ List<NamedType>? newNamedParameters) {
if (newNullability == null &&
newReturnType == null &&
newPositionalParameters == null &&
- newNamedParameters == null &&
- newTypedefType == null) {
+ newNamedParameters == null) {
// No nullability or types had to be substituted.
return null;
} else {
@@ -126,8 +116,7 @@
newNullability ?? node.nullability,
namedParameters: newNamedParameters ?? node.namedParameters,
typeParameters: newTypeParameters ?? node.typeParameters,
- requiredParameterCount: node.requiredParameterCount,
- typedefType: newTypedefType ?? node.typedefType);
+ requiredParameterCount: node.requiredParameterCount);
}
}
diff --git a/pkg/kernel/lib/src/unaliasing.dart b/pkg/kernel/lib/src/unaliasing.dart
new file mode 100644
index 0000000..107c696
--- /dev/null
+++ b/pkg/kernel/lib/src/unaliasing.dart
@@ -0,0 +1,111 @@
+// Copyright (c) 2022, 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.md file.
+
+import 'package:kernel/type_algebra.dart';
+
+import '../ast.dart';
+import 'legacy_erasure.dart';
+import 'replacement_visitor.dart';
+
+/// Replaces all occurrences of [TypedefType] in [type] with the corresponding
+/// unaliased type.
+///
+/// If [legacyEraseAliases] is `true`, the unaliased types will be legacy
+/// erased. This used when the [TypedefType] was used in a legacy library.
+DartType unalias(DartType type, {required bool legacyEraseAliases}) {
+ return rawUnalias(type, legacyEraseAliases: legacyEraseAliases) ?? type;
+}
+
+/// Replaces all occurrences of [TypedefType] in [types] with the corresponding
+/// unaliased types.
+///
+/// If [legacyEraseAliases] is `true`, the unaliased types will be legacy
+/// erased. This used when the [TypedefType] was used in a legacy library.
+List<DartType>? unaliasTypes(List<DartType>? types,
+ {required bool legacyEraseAliases}) {
+ if (types == null) return null;
+ return rawUnaliasTypes(types, legacyEraseAliases: legacyEraseAliases) ??
+ types;
+}
+
+/// Replaces all occurrences of [TypedefType] in [type] with the corresponding
+/// unaliased type, or returns `null` if no [TypedefType]s were found.
+///
+/// If [legacyEraseAliases] is `true`, the unaliased types will be legacy
+/// erased. This used when the [TypedefType] was used in a legacy library.
+DartType? rawUnalias(DartType type, {required bool legacyEraseAliases}) {
+ return type.accept1(
+ legacyEraseAliases
+ ? const _Unalias(legacyEraseAliases: true)
+ : const _Unalias(legacyEraseAliases: false),
+ Variance.covariant);
+}
+
+/// Replaces all occurrences of [TypedefType] in [types] with the corresponding
+/// unaliased types, or returns `null` if no [TypedefType]s were found.
+///
+/// If [legacyEraseAliases] is `true`, the unaliased types will be legacy
+/// erased. This used when the [TypedefType] was used in a legacy library.
+List<DartType>? rawUnaliasTypes(List<DartType> types,
+ {required bool legacyEraseAliases}) {
+ List<DartType>? newTypes;
+ for (int i = 0; i < types.length; i++) {
+ DartType typeArgument = types[i];
+ DartType? newTypeArgument =
+ rawUnalias(typeArgument, legacyEraseAliases: legacyEraseAliases);
+ if (newTypeArgument != null) {
+ newTypes ??= types.toList(growable: false);
+ newTypes[i] = newTypeArgument;
+ }
+ }
+ return newTypes;
+}
+
+/// Visitor that replaces all occurrences of [TypedefType] with the
+/// corresponding unaliased type, or returns `null` if no type was replaced.
+///
+/// If [legacyEraseAliases] is `true`, the unaliased types will be legacy
+/// erased. This used when the [TypedefType] was used in a legacy library.
+class _Unalias extends ReplacementVisitor {
+ final bool legacyEraseAliases;
+
+ const _Unalias({required this.legacyEraseAliases});
+
+ @override
+ DartType visitTypedefType(TypedefType node, int variance) {
+ DartType result;
+ if (node.typeArguments.isNotEmpty) {
+ List<DartType>? newTypeArguments = null;
+ for (int i = 0; i < node.typeArguments.length; i++) {
+ DartType? substitution = node.typeArguments[i].accept1(this, variance);
+ if (substitution != null) {
+ newTypeArguments ??= node.typeArguments.toList(growable: false);
+ newTypeArguments[i] = substitution;
+ }
+ }
+ if (newTypeArguments != null) {
+ result = new TypedefType(
+ node.typedefNode, node.nullability, newTypeArguments)
+ .unalias;
+ } else {
+ result = node.unalias;
+ }
+ } else {
+ result = node.unalias;
+ }
+ if (node.nullability == Nullability.legacy ||
+ node.typedefNode.type!.nullability == Nullability.legacy) {
+ // The typedef is defined or used in an opt-out library so the nullability
+ // is based on the use site alone.
+ result = result.withDeclaredNullability(node.nullability);
+ } else {
+ result = result.withDeclaredNullability(
+ uniteNullabilities(node.nullability, result.nullability));
+ }
+ if (legacyEraseAliases) {
+ result = legacyErasure(result);
+ }
+ return result;
+ }
+}
diff --git a/pkg/kernel/lib/testing/type_parser_environment.dart b/pkg/kernel/lib/testing/type_parser_environment.dart
index 1f9fab5..c550c02 100644
--- a/pkg/kernel/lib/testing/type_parser_environment.dart
+++ b/pkg/kernel/lib/testing/type_parser_environment.dart
@@ -414,14 +414,7 @@
f.positionalParameters, f.returnType, Nullability.nonNullable,
namedParameters: f.namedParameters,
typeParameters: f.typeParameters,
- requiredParameterCount: f.requiredParameterCount,
- typedefType: new TypedefType(
- def,
- Nullability.nonNullable,
- def.typeParameters
- .map((p) => new TypeParameterType(
- p, TypeParameterType.computeNullabilityFromBound(p)))
- .toList()));
+ requiredParameterCount: f.requiredParameterCount);
}
}
return def..type = type;
diff --git a/pkg/kernel/lib/type_algebra.dart b/pkg/kernel/lib/type_algebra.dart
index f776684..a0ee467 100644
--- a/pkg/kernel/lib/type_algebra.dart
+++ b/pkg/kernel/lib/type_algebra.dart
@@ -168,10 +168,7 @@
substitute(type.returnType), type.nullability,
namedParameters: type.namedParameters.map(substituteNamed).toList(),
typeParameters: freshTypeParameters,
- requiredParameterCount: type.requiredParameterCount,
- typedefType: type.typedefType == null
- ? null
- : substitute(type.typedefType!) as TypedefType);
+ requiredParameterCount: type.requiredParameterCount);
}
DartType substitute(DartType type) => substitution.substituteType(type);
@@ -769,15 +766,11 @@
: node.namedParameters.map(inner.visitNamedType).toList();
inner.invertVariance();
DartType returnType = inner.visit(node.returnType);
- TypedefType? typedefType = node.typedefType == null
- ? null
- : inner.visit(node.typedefType!) as TypedefType;
if (this.useCounter == before) return node;
return new FunctionType(positionalParameters, returnType, node.nullability,
namedParameters: namedParameters,
typeParameters: typeParameters,
- requiredParameterCount: node.requiredParameterCount,
- typedefType: typedefType);
+ requiredParameterCount: node.requiredParameterCount);
}
void bumpCountersUntil(_TypeSubstitutor target) {
@@ -941,7 +934,7 @@
@override
bool defaultDartType(DartType node) {
- throw new UnsupportedError("Unsupported type $node (${node.runtimeType}.");
+ throw new UnsupportedError("Unsupported type $node (${node.runtimeType}).");
}
bool visitNamedType(NamedType node) {
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index e19ef36..293015d 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -566,8 +566,7 @@
result.declaredNullability,
namedParameters: result.namedParameters,
typeParameters: freshTypeParameters.freshTypeParameters,
- requiredParameterCount: result.requiredParameterCount,
- typedefType: null);
+ requiredParameterCount: result.requiredParameterCount);
}
@override
diff --git a/pkg/kernel/lib/visitor.dart b/pkg/kernel/lib/visitor.dart
index cbd116e..d88c2a9 100644
--- a/pkg/kernel/lib/visitor.dart
+++ b/pkg/kernel/lib/visitor.dart
@@ -726,6 +726,8 @@
}
abstract class DartTypeVisitor1<R, T> {
+ const DartTypeVisitor1();
+
R defaultDartType(DartType node, T arg);
R visitInvalidType(InvalidType node, T arg) => defaultDartType(node, arg);
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 209910e..ecf11c7 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -989,10 +989,6 @@
@override
visitFunctionType(FunctionType node) {
node.visitChildren(this);
- final typedef = node.typedef;
- if (typedef != null) {
- shaker.addUsedTypedef(typedef);
- }
}
@override
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/annotation.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/annotation.dart.expect
index a86774c..220d635 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/annotation.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/annotation.dart.expect
@@ -2,7 +2,6 @@
import self as self;
import "dart:core" as core;
-typedef SomeType<contravariant T extends core::Object? = dynamic> = (core::List<T%>) → void;
abstract class A extends core::Object {
static method staticMethod() → void {}
}
diff --git a/runtime/vm/compiler/frontend/kernel_fingerprints.cc b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
index 21884e4..3a888c4 100644
--- a/runtime/vm/compiler/frontend/kernel_fingerprints.cc
+++ b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
@@ -310,11 +310,6 @@
}
}
- if (!simple) {
- // TODO(bkonyi): include in hash.
- SkipOptionalDartType(); // read typedef type.
- }
-
CalculateDartTypeFingerprint(); // read return type.
}
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 66a054c..e300802 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -2262,10 +2262,6 @@
}
}
- if (!simple) {
- SkipOptionalDartType(); // read typedef type.
- }
-
SkipDartType(); // read return type.
}
@@ -3262,10 +3258,6 @@
}
signature.FinalizeNameArray();
- if (!simple) {
- helper_->SkipOptionalDartType(); // read typedef type.
- }
-
BuildTypeInternal(); // read return type.
signature.set_result_type(result_);
diff --git a/runtime/vm/compiler/frontend/scope_builder.cc b/runtime/vm/compiler/frontend/scope_builder.cc
index 6363a5e..89d7660 100644
--- a/runtime/vm/compiler/frontend/scope_builder.cc
+++ b/runtime/vm/compiler/frontend/scope_builder.cc
@@ -1467,10 +1467,6 @@
}
}
- if (!simple) {
- helper_.SkipOptionalDartType(); // read typedef reference.
- }
-
VisitDartType(); // read return type.
}
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 08d9da7..6e6972f 100644
--- a/runtime/vm/kernel_binary.h
+++ b/runtime/vm/kernel_binary.h
@@ -20,8 +20,8 @@
static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
// Both version numbers are inclusive.
-static const uint32_t kMinSupportedKernelFormatVersion = 79;
-static const uint32_t kMaxSupportedKernelFormatVersion = 79;
+static const uint32_t kMinSupportedKernelFormatVersion = 80;
+static const uint32_t kMaxSupportedKernelFormatVersion = 80;
// Keep in sync with package:kernel/lib/binary/tag.dart
#define KERNEL_TAG_LIST(V) \
diff --git a/tests/language/generic/f_bounded_quantification_test.dart b/tests/language/generic/f_bounded_quantification_test.dart
index 4247e7d..6b7c5fd 100644
--- a/tests/language/generic/f_bounded_quantification_test.dart
+++ b/tests/language/generic/f_bounded_quantification_test.dart
@@ -17,10 +17,10 @@
main() {
FBound<Bar> fb = new FBound<Bar>();
FBound<SubBar> fsb = new FBound<SubBar>();
+//^
+// [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^
// [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^
@@ -28,10 +28,10 @@
FBound<Baz<Bar>> fbb = new FBound<Baz<Bar>>();
FBound<SubBaz<Bar>> fsbb = new FBound<SubBaz<Bar>>();
+//^
+// [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^
// [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^^^^^^
diff --git a/tests/language/generic/function_type_as_type_argument_test.dart b/tests/language/generic/function_type_as_type_argument_test.dart
index e932d53..0c4ae28 100644
--- a/tests/language/generic/function_type_as_type_argument_test.dart
+++ b/tests/language/generic/function_type_as_type_argument_test.dart
@@ -18,17 +18,16 @@
// Generic function types are not allowed as type arguments.
List<T Function<T>(T)> typedList = <T Function<T>(T)>[foo];
- // ^^^^^^^^^^^^^^^^
- // [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
- // ^
- // [cfe] A generic function type can't be used as a type argument.
+//^
+// [cfe] A generic function type can't be used as a type argument.
+// ^^^^^^^^^^^^^^^^
+// [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
// Type inference must also give an error.
var inferredList = [foo];
- // ^
- // [cfe] Generic function type 'T Function<T>(T)' inferred as a type argument.
// ^^^^^
// [analyzer] COMPILE_TIME_ERROR.COULD_NOT_INFER
+ // [cfe] Generic function type 'T Function<T>(T)' inferred as a type argument.
// No error if illegal type cannot be inferred.
var dynamicList = <dynamic>[foo];
diff --git a/tests/language/generic/super_bounded_types_error2_test.dart b/tests/language/generic/super_bounded_types_error2_test.dart
index 39d9d4c..eed2bff 100644
--- a/tests/language/generic/super_bounded_types_error2_test.dart
+++ b/tests/language/generic/super_bounded_types_error2_test.dart
@@ -50,2286 +50,2196 @@
FcovCyclicCoBound<Function(Never?)> x1;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Null)> x2;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(N)> x3;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
CFcon<Fcon<Never?>> x4;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<Fcon<Null>> x5;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<Fcon<N>> x6;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CcovCyclicCoBound<Function(Never?)> x7;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Null)> x8;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(N)> x9;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
// --- Same non-super-bounded types in a context.
A<FcovCyclicCoBound<Function(Never?)>> x10;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<FcovCyclicCoBound<Function(Null)>> x11;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<FcovCyclicCoBound<Function(N)>> x12;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<CFcon<Fcon<Never?>>> x13;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
A<CFcon<Fcon<Null>>> x14;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
A<CFcon<Fcon<N>>> x15;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
A<CcovCyclicCoBound<Function(Never?)>> x16;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
A<CcovCyclicCoBound<Function(Null)>> x17;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
A<CcovCyclicCoBound<Function(N)>> x18;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
FcovCyclicCoBound<Function(Never?)> Function() x19;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Null)> Function() x20;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(N)> Function() x21;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
CFcon<Fcon<Never?>> Function() x22;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<Fcon<Null>> Function() x23;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<Fcon<N>> Function() x24;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CcovCyclicCoBound<Function(Never?)> Function() x25;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Null)> Function() x26;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(N)> Function() x27;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(FcovCyclicCoBound<Function(Never?)>)) x28;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(FcovCyclicCoBound<Function(Null)>)) x29;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(FcovCyclicCoBound<Function(N)>)) x30;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(CFcon<Fcon<Never?>>)) x31;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(void Function(CFcon<Fcon<Null>>)) x32;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(void Function(CFcon<Fcon<N>>)) x33;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(void Function(CcovCyclicCoBound<Function(Never?)>)) x34;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(CcovCyclicCoBound<Function(Null)>)) x35;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(CcovCyclicCoBound<Function(N)>)) x36;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Never?)>) x37;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Null)>) x38;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(N)>) x39;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(CFcon<Fcon<Never?>>) x40;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<Fcon<Null>>) x41;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<Fcon<N>>) x42;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CcovCyclicCoBound<Function(Never?)>) x43;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Null)>) x44;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(N)>) x45;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Never?)>) Function() x46;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Null)>) Function() x47;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(N)>) Function() x48;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(CFcon<Fcon<Never?>>) Function() x49;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<Fcon<Null>>) Function() x50;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<Fcon<N>>) Function() x51;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CcovCyclicCoBound<Function(Never?)>) Function() x52;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Null)>) Function() x53;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(N)>) Function() x54;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends FcovCyclicCoBound<Function(Never?)>>() x55;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends FcovCyclicCoBound<Function(Null)>>() x56;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends FcovCyclicCoBound<Function(N)>>() x57;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends CFcon<Fcon<Never?>>>() x58;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends CFcon<Fcon<Null>>>() x59;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends CFcon<Fcon<N>>>() x60;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends CcovCyclicCoBound<Function(Never?)>>() x61;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends CcovCyclicCoBound<Function(Null)>>() x62;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends CcovCyclicCoBound<Function(N)>>() x63;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<FcovCyclicCoBound<Function(Never?)>>>() x64;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<FcovCyclicCoBound<Function(Null)>>>() x65;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<FcovCyclicCoBound<Function(N)>>>() x66;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<CFcon<Fcon<Never?>>>>() x67;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends A<CFcon<Fcon<Null>>>>() x68;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends A<CFcon<Fcon<N>>>>() x69;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends A<CcovCyclicCoBound<Function(Never?)>>>() x70;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<CcovCyclicCoBound<Function(Null)>>>() x71;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<CcovCyclicCoBound<Function(N)>>>() x72;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<FcovCyclicCoBound<Function(Never?)>> x73;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<FcovCyclicCoBound<Function(Null)>> x74;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<FcovCyclicCoBound<Function(N)>> x75;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<CFcon<Fcon<Never?>>> x76;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Finv<CFcon<Fcon<Null>>> x77;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Finv<CFcon<Fcon<N>>> x78;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Finv<CcovCyclicCoBound<Function(Never?)>> x79;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<CcovCyclicCoBound<Function(Null)>> x80;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<CcovCyclicCoBound<Function(N)>> x81;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<FcovCyclicCoBound<Function(Never?)>> x82;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<FcovCyclicCoBound<Function(Null)>> x83;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<FcovCyclicCoBound<Function(N)>> x84;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<CFcon<Fcon<Never?>>> x85;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Never?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Funu<CFcon<Fcon<Null>>> x86;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<Null>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Funu<CFcon<Fcon<N>>> x87;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
+// ^
+// [cfe] Type argument 'Fcon<N>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Funu<CcovCyclicCoBound<Function(Never?)>> x88;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Never?)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<CcovCyclicCoBound<Function(Null)>> x89;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(Null)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<CcovCyclicCoBound<Function(N)>> x90;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
// --- Top type in a contravariant position, not super-bounded.
FconBound<dynamic> x91;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<void> x92;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<Object?> x93;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<dynamic>> x94;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<void>> x95;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<Object?>> x96;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconCyclicBound<dynamic> x97;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<void> x98;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<Object?> x99;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<dynamic>> x100;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<void>> x101;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<Object?>> x102;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<dynamic>> x103;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<void>> x104;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<Object?>> x105;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<dynamic>>> x106;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<void>>> x107;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<Object?>>> x108;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<dynamic>>> x109;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<void>>> x110;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<Object?>>> x111;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<dynamic>>>> x112;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<void>>>> x113;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<Object?>>>> x114;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicCoBound<dynamic> x115;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<void> x116;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Object?> x117;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<dynamic>> x118;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<void>> x119;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<Object?>> x120;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(dynamic))> x121;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(void))> x122;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(Object?))> x123;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<dynamic>))> x124;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<void>))> x125;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<Object?>))> x126;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
// --- Same non-super-bounded types in a context.
A<FconBound<dynamic>> x127;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconBound<void>> x128;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconBound<Object?>> x129;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconBound<FutureOr<dynamic>>> x130;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconBound<FutureOr<void>>> x131;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconBound<FutureOr<Object?>>> x132;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
A<FconCyclicBound<dynamic>> x133;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<void>> x134;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<Object?>> x135;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<FutureOr<dynamic>>> x136;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<FutureOr<void>>> x137;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<FutureOr<Object?>>> x138;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<dynamic>>> x139;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<void>>> x140;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<Object?>>> x141;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<FutureOr<dynamic>>>> x142;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<FutureOr<void>>>> x143;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<FutureOr<Object?>>>> x144;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<dynamic>>>> x145;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<void>>>> x146;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<Object?>>>> x147;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<FutureOr<dynamic>>>>> x148;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<FutureOr<void>>>>> x149;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicBound<A<A<FutureOr<Object?>>>>> x150;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
A<FconCyclicCoBound<dynamic>> x151;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<void>> x152;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Object?>> x153;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<FutureOr<dynamic>>> x154;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<FutureOr<void>>> x155;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<FutureOr<Object?>>> x156;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(dynamic))>> x157;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(void))>> x158;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(Object?))>> x159;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>> x160;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(FutureOr<void>))>> x161;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
A<FconCyclicCoBound<Function(Function(FutureOr<Object?>))>> x162;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconBound<dynamic> Function() x163;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<void> Function() x164;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<Object?> Function() x165;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<dynamic>> Function() x166;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<void>> Function() x167;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconBound<FutureOr<Object?>> Function() x168;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
FconCyclicBound<dynamic> Function() x169;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<void> Function() x170;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<Object?> Function() x171;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<dynamic>> Function() x172;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<void>> Function() x173;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<FutureOr<Object?>> Function() x174;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<dynamic>> Function() x175;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<void>> Function() x176;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<Object?>> Function() x177;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<dynamic>>> Function() x178;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<void>>> Function() x179;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<FutureOr<Object?>>> Function() x180;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<dynamic>>> Function() x181;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<void>>> Function() x182;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<Object?>>> Function() x183;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<dynamic>>>> Function() x184;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<void>>>> Function() x185;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicBound<A<A<FutureOr<Object?>>>> Function() x186;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
FconCyclicCoBound<dynamic> Function() x187;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<void> Function() x188;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Object?> Function() x189;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<dynamic>> Function() x190;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<void>> Function() x191;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<FutureOr<Object?>> Function() x192;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(dynamic))> Function() x193;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(void))> Function() x194;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(Object?))> Function() x195;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<dynamic>))> Function() x196;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<void>))> Function() x197;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
FconCyclicCoBound<Function(Function(FutureOr<Object?>))> Function() x198;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconBound<dynamic>)) x199;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconBound<void>)) x200;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconBound<Object?>)) x201;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconBound<FutureOr<dynamic>>)) x202;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconBound<FutureOr<void>>)) x203;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconBound<FutureOr<Object?>>)) x204;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(void Function(FconCyclicBound<dynamic>)) x205;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<void>)) x206;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<Object?>)) x207;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<FutureOr<dynamic>>)) x208;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<FutureOr<void>>)) x209;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<FutureOr<Object?>>)) x210;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<dynamic>>)) x211;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<void>>)) x212;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<Object?>>)) x213;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<FutureOr<dynamic>>>)) x214;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<FutureOr<void>>>)) x215;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<FutureOr<Object?>>>)) x216;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<dynamic>>>)) x217;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<void>>>)) x218;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<Object?>>>)) x219;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<FutureOr<dynamic>>>>)) x220;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<FutureOr<void>>>>)) x221;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicBound<A<A<FutureOr<Object?>>>>)) x222;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(void Function(FconCyclicCoBound<dynamic>)) x223;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<void>)) x224;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<Object?>)) x225;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<FutureOr<dynamic>>)) x226;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<FutureOr<void>>)) x227;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<FutureOr<Object?>>)) x228;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(void Function(FconCyclicCoBound<Function(Function(dynamic))>))
//^
// [analyzer] unspecified
- x229;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x229;
void Function(void Function(FconCyclicCoBound<Function(Function(void))>))
//^
// [analyzer] unspecified
- x230;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x230;
void Function(void Function(FconCyclicCoBound<Function(Function(Object?))>))
//^
// [analyzer] unspecified
- x231;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x231;
void Function(
void Function(
FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>)) x232;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(
void Function(FconCyclicCoBound<Function(Function(FutureOr<void>))>))
//^
// [analyzer] unspecified
- x233;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x233;
void Function(
void Function(
FconCyclicCoBound<Function(Function(FutureOr<Object?>))>)) x234;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconBound<dynamic>) x235;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<void>) x236;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<Object?>) x237;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<dynamic>>) x238;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<void>>) x239;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<Object?>>) x240;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconCyclicBound<dynamic>) x241;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<void>) x242;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<Object?>) x243;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<dynamic>>) x244;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<void>>) x245;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<Object?>>) x246;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<dynamic>>) x247;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<void>>) x248;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<Object?>>) x249;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<dynamic>>>) x250;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<void>>>) x251;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<Object?>>>) x252;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<dynamic>>>) x253;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<void>>>) x254;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<Object?>>>) x255;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<dynamic>>>>) x256;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<void>>>>) x257;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<Object?>>>>) x258;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicCoBound<dynamic>) x259;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<void>) x260;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Object?>) x261;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<dynamic>>) x262;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<void>>) x263;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<Object?>>) x264;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(dynamic))>) x265;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(void))>) x266;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(Object?))>) x267;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>) x268;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(FutureOr<void>))>) x269;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(FutureOr<Object?>))>) x270;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconBound<dynamic>) Function() x271;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<void>) Function() x272;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<Object?>) Function() x273;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<dynamic>>) Function() x274;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<void>>) Function() x275;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconBound<FutureOr<Object?>>) Function() x276;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function(FconCyclicBound<dynamic>) Function() x277;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<void>) Function() x278;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<Object?>) Function() x279;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<dynamic>>) Function() x280;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<void>>) Function() x281;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<FutureOr<Object?>>) Function() x282;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<dynamic>>) Function() x283;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<void>>) Function() x284;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<Object?>>) Function() x285;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<dynamic>>>) Function() x286;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<void>>>) Function() x287;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<FutureOr<Object?>>>) Function() x288;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<dynamic>>>) Function() x289;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<void>>>) Function() x290;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<Object?>>>) Function() x291;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<dynamic>>>>) Function() x292;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<void>>>>) Function() x293;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicBound<A<A<FutureOr<Object?>>>>) Function() x294;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function(FconCyclicCoBound<dynamic>) Function() x295;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<void>) Function() x296;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Object?>) Function() x297;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<dynamic>>) Function() x298;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<void>>) Function() x299;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<FutureOr<Object?>>) Function() x300;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(dynamic))>) Function() x301;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(void))>) Function() x302;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(Object?))>) Function() x303;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function(FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>)
//^
// [analyzer] unspecified
- Function() x304;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ Function() x304;
void Function(FconCyclicCoBound<Function(Function(FutureOr<void>))>)
//^
// [analyzer] unspecified
- Function() x305;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ Function() x305;
void Function(FconCyclicCoBound<Function(Function(FutureOr<Object?>))>)
//^
// [analyzer] unspecified
- Function() x306;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ Function() x306;
void Function<Y extends FconBound<dynamic>>() x307;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconBound<void>>() x308;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconBound<Object?>>() x309;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconBound<FutureOr<dynamic>>>() x310;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconBound<FutureOr<void>>>() x311;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconBound<FutureOr<Object?>>>() x312;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends FconCyclicBound<dynamic>>() x313;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<void>>() x314;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<Object?>>() x315;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<FutureOr<dynamic>>>() x316;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<FutureOr<void>>>() x317;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<FutureOr<Object?>>>() x318;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<dynamic>>>() x319;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<void>>>() x320;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<Object?>>>() x321;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<FutureOr<dynamic>>>>() x322;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<FutureOr<void>>>>() x323;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<FutureOr<Object?>>>>() x324;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<dynamic>>>>() x325;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<void>>>>() x326;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<Object?>>>>() x327;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<FutureOr<dynamic>>>>>() x328;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<FutureOr<void>>>>>() x329;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicBound<A<A<FutureOr<Object?>>>>>() x330;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends FconCyclicCoBound<dynamic>>() x331;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<void>>() x332;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<Object?>>() x333;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<FutureOr<dynamic>>>() x334;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<FutureOr<void>>>() x335;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<FutureOr<Object?>>>() x336;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<Function(Function(dynamic))>>()
//^
// [analyzer] unspecified
- x337;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x337;
void Function<Y extends FconCyclicCoBound<Function(Function(void))>>() x338;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends FconCyclicCoBound<Function(Function(Object?))>>()
//^
// [analyzer] unspecified
- x339;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x339;
void Function<
Y extends FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>>()
//^
// [analyzer] unspecified
- x340;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x340;
void Function<
Y extends FconCyclicCoBound<Function(Function(FutureOr<void>))>>() x341;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<
Y extends FconCyclicCoBound<Function(Function(FutureOr<Object?>))>>()
//^
// [analyzer] unspecified
- x342;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x342;
void Function<Y extends A<FconBound<dynamic>>>() x343;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconBound<void>>>() x344;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconBound<Object?>>>() x345;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconBound<FutureOr<dynamic>>>>() x346;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconBound<FutureOr<void>>>>() x347;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconBound<FutureOr<Object?>>>>() x348;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
void Function<Y extends A<FconCyclicBound<dynamic>>>() x349;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<void>>>() x350;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<Object?>>>() x351;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<FutureOr<dynamic>>>>() x352;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<FutureOr<void>>>>() x353;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<FutureOr<Object?>>>>() x354;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<dynamic>>>>() x355;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<void>>>>() x356;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<Object?>>>>() x357;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<FutureOr<dynamic>>>>>() x358;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<FutureOr<void>>>>>() x359;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<FutureOr<Object?>>>>>() x360;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<dynamic>>>>>() x361;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<void>>>>>() x362;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<Object?>>>>>() x363;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<FutureOr<dynamic>>>>>>() x364;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<FutureOr<void>>>>>>() x365;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicBound<A<A<FutureOr<Object?>>>>>>() x366;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
void Function<Y extends A<FconCyclicCoBound<dynamic>>>() x367;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<void>>>() x368;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<Object?>>>() x369;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<FutureOr<dynamic>>>>() x370;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<FutureOr<void>>>>() x371;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<FutureOr<Object?>>>>() x372;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<Y extends A<FconCyclicCoBound<Function(Function(dynamic))>>>()
//^
// [analyzer] unspecified
- x373;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x373;
void Function<Y extends A<FconCyclicCoBound<Function(Function(void))>>>()
//^
// [analyzer] unspecified
- x374;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x374;
void Function<Y extends A<FconCyclicCoBound<Function(Function(Object?))>>>()
//^
// [analyzer] unspecified
- x375;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x375;
void Function<
Y extends A<
FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>>>() x376;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
void Function<
Y extends A<FconCyclicCoBound<Function(Function(FutureOr<void>))>>>()
//^
// [analyzer] unspecified
- x377;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+ x377;
void Function<
Y extends A<
FconCyclicCoBound<Function(Function(FutureOr<Object?>))>>>() x378;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconBound<dynamic>> x379;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconBound<void>> x380;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconBound<Object?>> x381;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconBound<FutureOr<dynamic>>> x382;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconBound<FutureOr<void>>> x383;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconBound<FutureOr<Object?>>> x384;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Finv<FconCyclicBound<dynamic>> x385;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<void>> x386;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<Object?>> x387;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<FutureOr<dynamic>>> x388;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<FutureOr<void>>> x389;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<FutureOr<Object?>>> x390;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<dynamic>>> x391;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<void>>> x392;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<Object?>>> x393;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<FutureOr<dynamic>>>> x394;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<FutureOr<void>>>> x395;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<FutureOr<Object?>>>> x396;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<dynamic>>>> x397;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<void>>>> x398;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<Object?>>>> x399;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<FutureOr<dynamic>>>>> x400;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<FutureOr<void>>>>> x401;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicBound<A<A<FutureOr<Object?>>>>> x402;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Finv<FconCyclicCoBound<dynamic>> x403;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<void>> x404;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Object?>> x405;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<FutureOr<dynamic>>> x406;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<FutureOr<void>>> x407;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<FutureOr<Object?>>> x408;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(dynamic))>> x409;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(void))>> x410;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(Object?))>> x411;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>> x412;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(FutureOr<void>))>> x413;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Finv<FconCyclicCoBound<Function(Function(FutureOr<Object?>))>> x414;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconBound<dynamic>> x415;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconBound<void>> x416;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconBound<Object?>> x417;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconBound<FutureOr<dynamic>>> x418;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconBound<FutureOr<void>>> x419;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconBound<FutureOr<Object?>>> x420;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'num' of the type variable 'X' on 'FconBound'.
Funu<FconCyclicBound<dynamic>> x421;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<void>> x422;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<Object?>> x423;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<FutureOr<dynamic>>> x424;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<FutureOr<void>>> x425;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<FutureOr<Object?>>> x426;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<dynamic>>> x427;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<dynamic>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<void>>> x428;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<void>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<Object?>>> x429;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object?>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<FutureOr<dynamic>>>> x430;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<FutureOr<void>>>> x431;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<FutureOr<Object?>>>> x432;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<dynamic>>>> x433;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<dynamic>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<void>>>> x434;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<void>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<Object?>>>> x435;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object?>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<FutureOr<dynamic>>>>> x436;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<dynamic>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<FutureOr<void>>>>> x437;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<void>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicBound<A<A<FutureOr<Object?>>>>> x438;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object?>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FconCyclicBound'.
Funu<FconCyclicCoBound<dynamic>> x439;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<void>> x440;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'void' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Object?>> x441;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<FutureOr<dynamic>>> x442;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<dynamic>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<dynamic>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<FutureOr<void>>> x443;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<void>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<void>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<FutureOr<Object?>>> x444;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object?>?' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
+// ^
+// [cfe] Type argument 'FutureOr<Object?>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(dynamic))>> x445;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(dynamic))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(void))>> x446;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(void))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(Object?))>> x447;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object?))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(FutureOr<dynamic>))>> x448;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<dynamic>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(FutureOr<void>))>> x449;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<void>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
Funu<FconCyclicCoBound<Function(Function(FutureOr<Object?>))>> x450;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object?>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FconCyclicCoBound'.
}
diff --git a/tests/language/generic/super_bounded_types_error_test.dart b/tests/language/generic/super_bounded_types_error_test.dart
index 5f523bc..7917fa7 100644
--- a/tests/language/generic/super_bounded_types_error_test.dart
+++ b/tests/language/generic/super_bounded_types_error_test.dart
@@ -62,1820 +62,1748 @@
FcovBound<Object> x1;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
FcovBound<FutureOr<Object>> x2;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
FcovCyclicBound<Object> x3;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<FutureOr<Object>> x4;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<Object>> x5;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<FutureOr<Object>>> x6;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<A<Object>>> x7;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<A<FutureOr<Object>>>> x8;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicCoBound<Object> x9;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<FutureOr<Object>> x10;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Function(Object))> x11;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Function(FutureOr<Object>))> x12;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
CFcov<Object> x13;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<FutureOr<Object>> x14;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Object>> x15;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<FutureOr<Object>>> x16;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Fcov<Object>>> x17;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Fcov<FutureOr<Object>>>> x18;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcon<Object> x19;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<FutureOr<Object>> x20;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFinv<Object> x21;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
CFinv<FutureOr<Object>> x22;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
CFunu<Object> x23;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
CFunu<FutureOr<Object>> x24;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
CcovBound<Object> x25;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
CcovBound<FutureOr<Object>> x26;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
CcovCyclicBound<Object> x27;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<FutureOr<Object>> x28;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<Object>> x29;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<FutureOr<Object>>> x30;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<A<Object>>> x31;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<A<FutureOr<Object>>>> x32;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicCoBound<Object> x33;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<FutureOr<Object>> x34;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Function(Object))> x35;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Function(FutureOr<Object>))> x36;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
// --- Same non-super-bounded types in a context.
A<FcovBound<Object>> x37;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
A<FcovBound<FutureOr<Object>>> x38;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
A<FcovCyclicBound<Object>> x39;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicBound<FutureOr<Object>>> x40;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicBound<A<Object>>> x41;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicBound<A<FutureOr<Object>>>> x42;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicBound<A<A<Object>>>> x43;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicBound<A<A<FutureOr<Object>>>>> x44;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
A<FcovCyclicCoBound<Object>> x45;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<FcovCyclicCoBound<FutureOr<Object>>> x46;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<FcovCyclicCoBound<Function(Function(Object))>> x47;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<FcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x48;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
A<CFcov<Object>> x49;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcov<FutureOr<Object>>> x50;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcov<Fcov<Object>>> x51;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcov<Fcov<FutureOr<Object>>>> x52;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcov<Fcov<Fcov<Object>>>> x53;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcov<Fcov<Fcov<FutureOr<Object>>>>> x54;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
A<CFcon<Object>> x55;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
A<CFcon<FutureOr<Object>>> x56;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
A<CFinv<Object>> x57;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
A<CFinv<FutureOr<Object>>> x58;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
A<CFunu<Object>> x59;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
A<CFunu<FutureOr<Object>>> x60;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
A<CcovBound<Object>> x61;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
A<CcovBound<FutureOr<Object>>> x62;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
A<CcovCyclicBound<Object>> x63;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicBound<FutureOr<Object>>> x64;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicBound<A<Object>>> x65;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicBound<A<FutureOr<Object>>>> x66;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicBound<A<A<Object>>>> x67;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicBound<A<A<FutureOr<Object>>>>> x68;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
A<CcovCyclicCoBound<Object>> x69;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
A<CcovCyclicCoBound<FutureOr<Object>>> x70;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
A<CcovCyclicCoBound<Function(Function(Object))>> x71;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
A<CcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x72;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
FcovBound<Object> Function() x73;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
FcovBound<FutureOr<Object>> Function() x74;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
FcovCyclicBound<Object> Function() x75;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<FutureOr<Object>> Function() x76;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<Object>> Function() x77;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<FutureOr<Object>>> Function() x78;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<A<Object>>> Function() x79;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicBound<A<A<FutureOr<Object>>>> Function() x80;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
FcovCyclicCoBound<Object> Function() x81;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<FutureOr<Object>> Function() x82;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Function(Object))> Function() x83;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
FcovCyclicCoBound<Function(Function(FutureOr<Object>))> Function() x84;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
CFcov<Object> Function() x85;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<FutureOr<Object>> Function() x86;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Object>> Function() x87;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<FutureOr<Object>>> Function() x88;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Fcov<Object>>> Function() x89;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcov<Fcov<Fcov<FutureOr<Object>>>> Function() x90;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
CFcon<Object> Function() x91;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFcon<FutureOr<Object>> Function() x92;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
CFinv<Object> Function() x93;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
CFinv<FutureOr<Object>> Function() x94;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
CFunu<Object> Function() x95;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
CFunu<FutureOr<Object>> Function() x96;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
CcovBound<Object> Function() x97;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
CcovBound<FutureOr<Object>> Function() x98;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
CcovCyclicBound<Object> Function() x99;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<FutureOr<Object>> Function() x100;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<Object>> Function() x101;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<FutureOr<Object>>> Function() x102;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<A<Object>>> Function() x103;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicBound<A<A<FutureOr<Object>>>> Function() x104;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
CcovCyclicCoBound<Object> Function() x105;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<FutureOr<Object>> Function() x106;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Function(Object))> Function() x107;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
CcovCyclicCoBound<Function(Function(FutureOr<Object>))> Function() x108;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(FcovBound<Object>)) x109;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(void Function(FcovBound<FutureOr<Object>>)) x110;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(void Function(FcovCyclicBound<Object>)) x111;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicBound<FutureOr<Object>>)) x112;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicBound<A<Object>>)) x113;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicBound<A<FutureOr<Object>>>)) x114;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicBound<A<A<Object>>>)) x115;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicBound<A<A<FutureOr<Object>>>>)) x116;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(void Function(FcovCyclicCoBound<Object>)) x117;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(FcovCyclicCoBound<FutureOr<Object>>)) x118;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(FcovCyclicCoBound<Function(Function(Object))>))
//^
// [analyzer] unspecified
- x119;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
+ x119;
void Function(
void Function(
FcovCyclicCoBound<Function(Function(FutureOr<Object>))>)) x120;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(void Function(CFcov<Object>)) x121;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcov<FutureOr<Object>>)) x122;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcov<Fcov<Object>>)) x123;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcov<Fcov<FutureOr<Object>>>)) x124;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcov<Fcov<Fcov<Object>>>)) x125;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcov<Fcov<Fcov<FutureOr<Object>>>>)) x126;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(void Function(CFcon<Object>)) x127;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(void Function(CFcon<FutureOr<Object>>)) x128;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(void Function(CFinv<Object>)) x129;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(void Function(CFinv<FutureOr<Object>>)) x130;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(void Function(CFunu<Object>)) x131;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(void Function(CFunu<FutureOr<Object>>)) x132;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(void Function(CcovBound<Object>)) x133;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(void Function(CcovBound<FutureOr<Object>>)) x134;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(void Function(CcovCyclicBound<Object>)) x135;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicBound<FutureOr<Object>>)) x136;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicBound<A<Object>>)) x137;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicBound<A<FutureOr<Object>>>)) x138;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicBound<A<A<Object>>>)) x139;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicBound<A<A<FutureOr<Object>>>>)) x140;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(void Function(CcovCyclicCoBound<Object>)) x141;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(CcovCyclicCoBound<FutureOr<Object>>)) x142;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(void Function(CcovCyclicCoBound<Function(Function(Object))>))
//^
// [analyzer] unspecified
- x143;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
+ x143;
void Function(
void Function(
CcovCyclicCoBound<Function(Function(FutureOr<Object>))>)) x144;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(FcovBound<Object>) x145;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(FcovBound<FutureOr<Object>>) x146;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(FcovCyclicBound<Object>) x147;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<FutureOr<Object>>) x148;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<Object>>) x149;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<FutureOr<Object>>>) x150;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<A<Object>>>) x151;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<A<FutureOr<Object>>>>) x152;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicCoBound<Object>) x153;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<FutureOr<Object>>) x154;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Function(Object))>) x155;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Function(FutureOr<Object>))>) x156;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(CFcov<Object>) x157;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<FutureOr<Object>>) x158;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Object>>) x159;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<FutureOr<Object>>>) x160;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Fcov<Object>>>) x161;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Fcov<FutureOr<Object>>>>) x162;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcon<Object>) x163;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<FutureOr<Object>>) x164;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFinv<Object>) x165;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(CFinv<FutureOr<Object>>) x166;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(CFunu<Object>) x167;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(CFunu<FutureOr<Object>>) x168;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(CcovBound<Object>) x169;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(CcovBound<FutureOr<Object>>) x170;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(CcovCyclicBound<Object>) x171;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<FutureOr<Object>>) x172;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<Object>>) x173;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<FutureOr<Object>>>) x174;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<A<Object>>>) x175;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<A<FutureOr<Object>>>>) x176;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicCoBound<Object>) x177;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<FutureOr<Object>>) x178;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Function(Object))>) x179;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Function(FutureOr<Object>))>) x180;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(FcovBound<Object>) Function() x181;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(FcovBound<FutureOr<Object>>) Function() x182;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function(FcovCyclicBound<Object>) Function() x183;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<FutureOr<Object>>) Function() x184;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<Object>>) Function() x185;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<FutureOr<Object>>>) Function() x186;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<A<Object>>>) Function() x187;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicBound<A<A<FutureOr<Object>>>>) Function() x188;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function(FcovCyclicCoBound<Object>) Function() x189;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<FutureOr<Object>>) Function() x190;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Function(Object))>) Function() x191;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function(FcovCyclicCoBound<Function(Function(FutureOr<Object>))>)
//^
// [analyzer] unspecified
- Function() x192;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
+ Function() x192;
void Function(CFcov<Object>) Function() x193;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<FutureOr<Object>>) Function() x194;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Object>>) Function() x195;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<FutureOr<Object>>>) Function() x196;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Fcov<Object>>>) Function() x197;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcov<Fcov<Fcov<FutureOr<Object>>>>) Function() x198;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function(CFcon<Object>) Function() x199;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFcon<FutureOr<Object>>) Function() x200;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function(CFinv<Object>) Function() x201;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(CFinv<FutureOr<Object>>) Function() x202;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function(CFunu<Object>) Function() x203;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(CFunu<FutureOr<Object>>) Function() x204;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function(CcovBound<Object>) Function() x205;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(CcovBound<FutureOr<Object>>) Function() x206;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function(CcovCyclicBound<Object>) Function() x207;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<FutureOr<Object>>) Function() x208;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<Object>>) Function() x209;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<FutureOr<Object>>>) Function() x210;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<A<Object>>>) Function() x211;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicBound<A<A<FutureOr<Object>>>>) Function() x212;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function(CcovCyclicCoBound<Object>) Function() x213;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<FutureOr<Object>>) Function() x214;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Function(Object))>) Function() x215;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function(CcovCyclicCoBound<Function(Function(FutureOr<Object>))>)
//^
// [analyzer] unspecified
- Function() x216;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
+ Function() x216;
void Function<Y extends FcovBound<Object>>() x217;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function<Y extends FcovBound<FutureOr<Object>>>() x218;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function<Y extends FcovCyclicBound<Object>>() x219;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicBound<FutureOr<Object>>>() x220;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicBound<A<Object>>>() x221;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicBound<A<FutureOr<Object>>>>() x222;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicBound<A<A<Object>>>>() x223;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicBound<A<A<FutureOr<Object>>>>>() x224;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends FcovCyclicCoBound<Object>>() x225;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends FcovCyclicCoBound<FutureOr<Object>>>() x226;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends FcovCyclicCoBound<Function(Function(Object))>>() x227;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<
Y extends FcovCyclicCoBound<Function(Function(FutureOr<Object>))>>() x228;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends CFcov<Object>>() x229;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcov<FutureOr<Object>>>() x230;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcov<Fcov<Object>>>() x231;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcov<Fcov<FutureOr<Object>>>>() x232;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcov<Fcov<Fcov<Object>>>>() x233;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcov<Fcov<Fcov<FutureOr<Object>>>>>() x234;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends CFcon<Object>>() x235;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends CFcon<FutureOr<Object>>>() x236;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends CFinv<Object>>() x237;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function<Y extends CFinv<FutureOr<Object>>>() x238;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function<Y extends CFunu<Object>>() x239;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function<Y extends CFunu<FutureOr<Object>>>() x240;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function<Y extends CcovBound<Object>>() x241;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function<Y extends CcovBound<FutureOr<Object>>>() x242;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function<Y extends CcovCyclicBound<Object>>() x243;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicBound<FutureOr<Object>>>() x244;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicBound<A<Object>>>() x245;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicBound<A<FutureOr<Object>>>>() x246;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicBound<A<A<Object>>>>() x247;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicBound<A<A<FutureOr<Object>>>>>() x248;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends CcovCyclicCoBound<Object>>() x249;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends CcovCyclicCoBound<FutureOr<Object>>>() x250;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends CcovCyclicCoBound<Function(Function(Object))>>() x251;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<
Y extends CcovCyclicCoBound<Function(Function(FutureOr<Object>))>>() x252;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<FcovBound<Object>>>() x253;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function<Y extends A<FcovBound<FutureOr<Object>>>>() x254;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
void Function<Y extends A<FcovCyclicBound<Object>>>() x255;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicBound<FutureOr<Object>>>>() x256;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicBound<A<Object>>>>() x257;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicBound<A<FutureOr<Object>>>>>() x258;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicBound<A<A<Object>>>>>() x259;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicBound<A<A<FutureOr<Object>>>>>>() x260;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
void Function<Y extends A<FcovCyclicCoBound<Object>>>() x261;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<FcovCyclicCoBound<FutureOr<Object>>>>() x262;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<FcovCyclicCoBound<Function(Function(Object))>>>()
//^
// [analyzer] unspecified
- x263;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
+ x263;
void Function<
Y extends A<
FcovCyclicCoBound<Function(Function(FutureOr<Object>))>>>() x264;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
void Function<Y extends A<CFcov<Object>>>() x265;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcov<FutureOr<Object>>>>() x266;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcov<Fcov<Object>>>>() x267;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcov<Fcov<FutureOr<Object>>>>>() x268;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcov<Fcov<Fcov<Object>>>>>() x269;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcov<Fcov<Fcov<FutureOr<Object>>>>>>() x270;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
void Function<Y extends A<CFcon<Object>>>() x271;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends A<CFcon<FutureOr<Object>>>>() x272;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
void Function<Y extends A<CFinv<Object>>>() x273;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function<Y extends A<CFinv<FutureOr<Object>>>>() x274;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
void Function<Y extends A<CFunu<Object>>>() x275;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function<Y extends A<CFunu<FutureOr<Object>>>>() x276;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
void Function<Y extends A<CcovBound<Object>>>() x277;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function<Y extends A<CcovBound<FutureOr<Object>>>>() x278;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
void Function<Y extends A<CcovCyclicBound<Object>>>() x279;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicBound<FutureOr<Object>>>>() x280;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicBound<A<Object>>>>() x281;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicBound<A<FutureOr<Object>>>>>() x282;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicBound<A<A<Object>>>>>() x283;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicBound<A<A<FutureOr<Object>>>>>>() x284;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
void Function<Y extends A<CcovCyclicCoBound<Object>>>() x285;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<CcovCyclicCoBound<FutureOr<Object>>>>() x286;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
void Function<Y extends A<CcovCyclicCoBound<Function(Function(Object))>>>()
//^
// [analyzer] unspecified
- x287;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
+ x287;
void Function<
Y extends A<
CcovCyclicCoBound<Function(Function(FutureOr<Object>))>>>() x288;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<FcovBound<Object>> x289;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
Finv<FcovBound<FutureOr<Object>>> x290;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
Finv<FcovCyclicBound<Object>> x291;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicBound<FutureOr<Object>>> x292;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicBound<A<Object>>> x293;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicBound<A<FutureOr<Object>>>> x294;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicBound<A<A<Object>>>> x295;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicBound<A<A<FutureOr<Object>>>>> x296;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Finv<FcovCyclicCoBound<Object>> x297;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<FcovCyclicCoBound<FutureOr<Object>>> x298;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<FcovCyclicCoBound<Function(Function(Object))>> x299;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<FcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x300;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Finv<CFcov<Object>> x301;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcov<FutureOr<Object>>> x302;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcov<Fcov<Object>>> x303;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcov<Fcov<FutureOr<Object>>>> x304;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcov<Fcov<Fcov<Object>>>> x305;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcov<Fcov<Fcov<FutureOr<Object>>>>> x306;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Finv<CFcon<Object>> x307;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Finv<CFcon<FutureOr<Object>>> x308;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Finv<CFinv<Object>> x309;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
Finv<CFinv<FutureOr<Object>>> x310;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
Finv<CFunu<Object>> x311;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
Finv<CFunu<FutureOr<Object>>> x312;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
Finv<CcovBound<Object>> x313;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
Finv<CcovBound<FutureOr<Object>>> x314;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
Finv<CcovCyclicBound<Object>> x315;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicBound<FutureOr<Object>>> x316;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicBound<A<Object>>> x317;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicBound<A<FutureOr<Object>>>> x318;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicBound<A<A<Object>>>> x319;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicBound<A<A<FutureOr<Object>>>>> x320;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Finv<CcovCyclicCoBound<Object>> x321;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<CcovCyclicCoBound<FutureOr<Object>>> x322;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<CcovCyclicCoBound<Function(Function(Object))>> x323;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Finv<CcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x324;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<FcovBound<Object>> x325;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
Funu<FcovBound<FutureOr<Object>>> x326;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FcovBound'.
Funu<FcovCyclicBound<Object>> x327;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicBound<FutureOr<Object>>> x328;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicBound<A<Object>>> x329;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicBound<A<FutureOr<Object>>>> x330;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicBound<A<A<Object>>>> x331;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicBound<A<A<FutureOr<Object>>>>> x332;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FcovCyclicBound'.
Funu<FcovCyclicCoBound<Object>> x333;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<FcovCyclicCoBound<FutureOr<Object>>> x334;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<FcovCyclicCoBound<Function(Function(Object))>> x335;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<FcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x336;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FcovCyclicCoBound'.
Funu<CFcov<Object>> x337;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcov<FutureOr<Object>>> x338;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcov<Fcov<Object>>> x339;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Object>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcov<Fcov<FutureOr<Object>>>> x340;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<FutureOr<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcov<Fcov<Fcov<Object>>>> x341;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'Object Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<Object>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcov<Fcov<Fcov<FutureOr<Object>>>>> x342;
//^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'FutureOr<Object> Function() Function()' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
+// ^
+// [cfe] Type argument 'Fcov<Fcov<FutureOr<Object>>>' doesn't conform to the bound 'X Function()' of the type variable 'X' on 'CFcov'.
Funu<CFcon<Object>> x343;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Funu<CFcon<FutureOr<Object>>> x344;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CFcon'.
Funu<CFinv<Object>> x345;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
Funu<CFinv<FutureOr<Object>>> x346;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'X Function(X)' of the type variable 'X' on 'CFinv'.
Funu<CFunu<Object>> x347;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
Funu<CFunu<FutureOr<Object>>> x348;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function()' of the type variable 'X' on 'CFunu'.
Funu<CcovBound<Object>> x349;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
Funu<CcovBound<FutureOr<Object>>> x350;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'CcovBound'.
Funu<CcovCyclicBound<Object>> x351;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicBound<FutureOr<Object>>> x352;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicBound<A<Object>>> x353;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicBound<A<FutureOr<Object>>>> x354;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicBound<A<A<Object>>>> x355;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicBound<A<A<FutureOr<Object>>>>> x356;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'CcovCyclicBound'.
Funu<CcovCyclicCoBound<Object>> x357;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<CcovCyclicCoBound<FutureOr<Object>>> x358;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<CcovCyclicCoBound<Function(Function(Object))>> x359;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
Funu<CcovCyclicCoBound<Function(Function(FutureOr<Object>))>> x360;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'CcovCyclicCoBound'.
}
@@ -1884,612 +1812,588 @@
FinvBound<Object> x1;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
FinvBound<FutureOr<Object>> x2;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
FinvCyclicBound<Object> x3;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<FutureOr<Object>> x4;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<Object>> x5;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<FutureOr<Object>>> x6;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<A<Object>>> x7;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<A<FutureOr<Object>>>> x8;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicCoBound<Object> x9;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<FutureOr<Object>> x10;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<Function(Function(Object))> x11;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<Function(Function(FutureOr<Object>))> x12;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
// --- Same non-super-bounded types in a context.
A<FinvBound<Object>> x13;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
A<FinvBound<FutureOr<Object>>> x14;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
A<FinvCyclicBound<Object>> x15;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicBound<FutureOr<Object>>> x16;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicBound<A<Object>>> x17;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicBound<A<FutureOr<Object>>>> x18;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicBound<A<A<Object>>>> x19;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicBound<A<A<FutureOr<Object>>>>> x20;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
A<FinvCyclicCoBound<Object>> x21;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
A<FinvCyclicCoBound<FutureOr<Object>>> x22;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
A<FinvCyclicCoBound<Function(Function(Object))>> x23;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
A<FinvCyclicCoBound<Function(Function(FutureOr<Object>))>> x24;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvBound<Object> Function() x25;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
FinvBound<FutureOr<Object>> Function() x26;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
FinvCyclicBound<Object> Function() x27;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<FutureOr<Object>> Function() x28;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<Object>> Function() x29;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<FutureOr<Object>>> Function() x30;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<A<Object>>> Function() x31;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicBound<A<A<FutureOr<Object>>>> Function() x32;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
FinvCyclicCoBound<Object> Function() x33;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<FutureOr<Object>> Function() x34;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<Function(Function(Object))> Function() x35;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
FinvCyclicCoBound<Function(Function(FutureOr<Object>))> Function() x36;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(void Function(FinvBound<Object>)) x37;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(void Function(FinvBound<FutureOr<Object>>)) x38;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(void Function(FinvCyclicBound<Object>)) x39;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicBound<FutureOr<Object>>)) x40;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicBound<A<Object>>)) x41;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicBound<A<FutureOr<Object>>>)) x42;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicBound<A<A<Object>>>)) x43;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicBound<A<A<FutureOr<Object>>>>)) x44;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(void Function(FinvCyclicCoBound<Object>)) x45;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(void Function(FinvCyclicCoBound<FutureOr<Object>>)) x46;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(void Function(FinvCyclicCoBound<Function(Function(Object))>))
//^
// [analyzer] unspecified
- x47;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
+ x47;
void Function(
void Function(
FinvCyclicCoBound<Function(Function(FutureOr<Object>))>)) x48;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvBound<Object>) x49;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(FinvBound<FutureOr<Object>>) x50;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(FinvCyclicBound<Object>) x51;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<FutureOr<Object>>) x52;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<Object>>) x53;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<FutureOr<Object>>>) x54;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<A<Object>>>) x55;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<A<FutureOr<Object>>>>) x56;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicCoBound<Object>) x57;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<FutureOr<Object>>) x58;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<Function(Function(Object))>) x59;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<Function(Function(FutureOr<Object>))>) x60;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvBound<Object>) Function() x61;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(FinvBound<FutureOr<Object>>) Function() x62;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function(FinvCyclicBound<Object>) Function() x63;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<FutureOr<Object>>) Function() x64;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<Object>>) Function() x65;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<FutureOr<Object>>>) Function() x66;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<A<Object>>>) Function() x67;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicBound<A<A<FutureOr<Object>>>>) Function() x68;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function(FinvCyclicCoBound<Object>) Function() x69;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<FutureOr<Object>>) Function() x70;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<Function(Function(Object))>) Function() x71;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function(FinvCyclicCoBound<Function(Function(FutureOr<Object>))>)
//^
// [analyzer] unspecified
- Function() x72;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
+ Function() x72;
void Function<Y extends FinvBound<Object>>() x73;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function<Y extends FinvBound<FutureOr<Object>>>() x74;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function<Y extends FinvCyclicBound<Object>>() x75;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicBound<FutureOr<Object>>>() x76;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicBound<A<Object>>>() x77;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicBound<A<FutureOr<Object>>>>() x78;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicBound<A<A<Object>>>>() x79;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicBound<A<A<FutureOr<Object>>>>>() x80;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends FinvCyclicCoBound<Object>>() x81;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<Y extends FinvCyclicCoBound<FutureOr<Object>>>() x82;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<Y extends FinvCyclicCoBound<Function(Function(Object))>>() x83;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<
Y extends FinvCyclicCoBound<Function(Function(FutureOr<Object>))>>() x84;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<Y extends A<FinvBound<Object>>>() x85;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function<Y extends A<FinvBound<FutureOr<Object>>>>() x86;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
void Function<Y extends A<FinvCyclicBound<Object>>>() x87;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicBound<FutureOr<Object>>>>() x88;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicBound<A<Object>>>>() x89;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicBound<A<FutureOr<Object>>>>>() x90;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicBound<A<A<Object>>>>>() x91;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicBound<A<A<FutureOr<Object>>>>>>() x92;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
void Function<Y extends A<FinvCyclicCoBound<Object>>>() x93;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<Y extends A<FinvCyclicCoBound<FutureOr<Object>>>>() x94;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
void Function<Y extends A<FinvCyclicCoBound<Function(Function(Object))>>>()
//^
// [analyzer] unspecified
- x95;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
+ x95;
void Function<
Y extends A<
FinvCyclicCoBound<Function(Function(FutureOr<Object>))>>>() x96;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Finv<FinvBound<Object>> x97;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
Finv<FinvBound<FutureOr<Object>>> x98;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
Finv<FinvCyclicBound<Object>> x99;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicBound<FutureOr<Object>>> x100;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicBound<A<Object>>> x101;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicBound<A<FutureOr<Object>>>> x102;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicBound<A<A<Object>>>> x103;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicBound<A<A<FutureOr<Object>>>>> x104;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Finv<FinvCyclicCoBound<Object>> x105;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Finv<FinvCyclicCoBound<FutureOr<Object>>> x106;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Finv<FinvCyclicCoBound<Function(Function(Object))>> x107;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Finv<FinvCyclicCoBound<Function(Function(FutureOr<Object>))>> x108;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Funu<FinvBound<Object>> x109;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
Funu<FinvBound<FutureOr<Object>>> x110;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FinvBound'.
Funu<FinvCyclicBound<Object>> x111;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicBound<FutureOr<Object>>> x112;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicBound<A<Object>>> x113;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicBound<A<FutureOr<Object>>>> x114;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicBound<A<A<Object>>>> x115;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicBound<A<A<FutureOr<Object>>>>> x116;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FinvCyclicBound'.
Funu<FinvCyclicCoBound<Object>> x117;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Funu<FinvCyclicCoBound<FutureOr<Object>>> x118;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Funu<FinvCyclicCoBound<Function(Function(Object))>> x119;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
Funu<FinvCyclicCoBound<Function(Function(FutureOr<Object>))>> x120;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
}
@@ -2498,612 +2402,588 @@
FunuBound<Object> x1;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
FunuBound<FutureOr<Object>> x2;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
FunuCyclicBound<Object> x3;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<FutureOr<Object>> x4;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<Object>> x5;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<FutureOr<Object>>> x6;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<A<Object>>> x7;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<A<FutureOr<Object>>>> x8;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicCoBound<Object> x9;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<FutureOr<Object>> x10;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<Function(Function(Object))> x13;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<Function(Function(FutureOr<Object>))> x14;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
// --- Same non-super-bounded types in a context.
A<FunuBound<Object>> x19;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
A<FunuBound<FutureOr<Object>>> x20;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
A<FunuCyclicBound<Object>> x21;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicBound<FutureOr<Object>>> x22;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicBound<A<Object>>> x23;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicBound<A<FutureOr<Object>>>> x24;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicBound<A<A<Object>>>> x25;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicBound<A<A<FutureOr<Object>>>>> x26;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
A<FunuCyclicCoBound<Object>> x27;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
A<FunuCyclicCoBound<FutureOr<Object>>> x28;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
A<FunuCyclicCoBound<Function(Function(Object))>> x31;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
A<FunuCyclicCoBound<Function(Function(FutureOr<Object>))>> x32;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuBound<Object> Function() x37;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
FunuBound<FutureOr<Object>> Function() x38;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
FunuCyclicBound<Object> Function() x39;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<FutureOr<Object>> Function() x40;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<Object>> Function() x41;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<FutureOr<Object>>> Function() x42;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<A<Object>>> Function() x43;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicBound<A<A<FutureOr<Object>>>> Function() x44;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
FunuCyclicCoBound<Object> Function() x45;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<FutureOr<Object>> Function() x46;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<Function(Function(Object))> Function() x49;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<Function(Function(FutureOr<Object>))> Function() x50;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(void Function(FunuBound<Object>)) x55;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(void Function(FunuBound<FutureOr<Object>>)) x56;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(void Function(FunuCyclicBound<Object>)) x57;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicBound<FutureOr<Object>>)) x58;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicBound<A<Object>>)) x59;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicBound<A<FutureOr<Object>>>)) x60;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicBound<A<A<Object>>>)) x61;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicBound<A<A<FutureOr<Object>>>>)) x62;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(void Function(FunuCyclicCoBound<Object>)) x63;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(void Function(FunuCyclicCoBound<FutureOr<Object>>)) x64;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(void Function(FunuCyclicCoBound<Function(Function(Object))>))
//^
// [analyzer] unspecified
- x67;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
+ x67;
void Function(
void Function(
FunuCyclicCoBound<Function(Function(FutureOr<Object>))>)) x68;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuBound<Object>) x73;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(FunuBound<FutureOr<Object>>) x74;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(FunuCyclicBound<Object>) x75;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<FutureOr<Object>>) x76;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<Object>>) x77;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<FutureOr<Object>>>) x78;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<A<Object>>>) x79;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<A<FutureOr<Object>>>>) x80;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicCoBound<Object>) x81;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<FutureOr<Object>>) x82;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<Function(Function(Object))>) x85;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<Function(Function(FutureOr<Object>))>) x86;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuBound<Object>) Function() x91;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(FunuBound<FutureOr<Object>>) Function() x92;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function(FunuCyclicBound<Object>) Function() x93;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<FutureOr<Object>>) Function() x94;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<Object>>) Function() x95;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<FutureOr<Object>>>) Function() x96;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<A<Object>>>) Function() x97;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicBound<A<A<FutureOr<Object>>>>) Function() x98;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function(FunuCyclicCoBound<Object>) Function() x99;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<FutureOr<Object>>) Function() x100;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<Function(Function(Object))>) Function() x103;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function(FunuCyclicCoBound<Function(Function(FutureOr<Object>))>)
//^
// [analyzer] unspecified
- Function() x104;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
+ Function() x104;
void Function<Y extends FunuBound<Object>>() x109;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function<Y extends FunuBound<FutureOr<Object>>>() x110;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function<Y extends FunuCyclicBound<Object>>() x111;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicBound<FutureOr<Object>>>() x112;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicBound<A<Object>>>() x113;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicBound<A<FutureOr<Object>>>>() x114;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicBound<A<A<Object>>>>() x115;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicBound<A<A<FutureOr<Object>>>>>() x116;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends FunuCyclicCoBound<Object>>() x117;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<Y extends FunuCyclicCoBound<FutureOr<Object>>>() x118;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<Y extends FunuCyclicCoBound<Function(Function(Object))>>() x121;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<
Y extends FunuCyclicCoBound<Function(Function(FutureOr<Object>))>>() x122;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<Y extends A<FunuBound<Object>>>() x127;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function<Y extends A<FunuBound<FutureOr<Object>>>>() x128;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
void Function<Y extends A<FunuCyclicBound<Object>>>() x129;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicBound<FutureOr<Object>>>>() x130;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicBound<A<Object>>>>() x131;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicBound<A<FutureOr<Object>>>>>() x132;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicBound<A<A<Object>>>>>() x133;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicBound<A<A<FutureOr<Object>>>>>>() x134;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
void Function<Y extends A<FunuCyclicCoBound<Object>>>() x135;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<Y extends A<FunuCyclicCoBound<FutureOr<Object>>>>() x136;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
void Function<Y extends A<FunuCyclicCoBound<Function(Function(Object))>>>()
//^
// [analyzer] unspecified
- x139;
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
+ x139;
void Function<
Y extends A<
FunuCyclicCoBound<Function(Function(FutureOr<Object>))>>>() x140;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Finv<FunuBound<Object>> x145;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
Finv<FunuBound<FutureOr<Object>>> x146;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
Finv<FunuCyclicBound<Object>> x147;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicBound<FutureOr<Object>>> x148;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicBound<A<Object>>> x149;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicBound<A<FutureOr<Object>>>> x150;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicBound<A<A<Object>>>> x151;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicBound<A<A<FutureOr<Object>>>>> x152;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Finv<FunuCyclicCoBound<Object>> x153;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Finv<FunuCyclicCoBound<FutureOr<Object>>> x154;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Finv<FunuCyclicCoBound<Function(Function(Object))>> x157;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Finv<FunuCyclicCoBound<Function(Function(FutureOr<Object>))>> x158;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Funu<FunuBound<Object>> x163;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
Funu<FunuBound<FutureOr<Object>>> x164;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'num' of the type variable 'X' on 'FunuBound'.
Funu<FunuCyclicBound<Object>> x165;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicBound<FutureOr<Object>>> x166;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicBound<A<Object>>> x167;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<Object>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicBound<A<FutureOr<Object>>>> x168;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<FutureOr<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicBound<A<A<Object>>>> x169;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<Object>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicBound<A<A<FutureOr<Object>>>>> x170;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'A<A<FutureOr<Object>>>' doesn't conform to the bound 'A<X>' of the type variable 'X' on 'FunuCyclicBound'.
Funu<FunuCyclicCoBound<Object>> x171;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'Object' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Funu<FunuCyclicCoBound<FutureOr<Object>>> x172;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'FutureOr<Object>' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Funu<FunuCyclicCoBound<Function(Function(Object))>> x175;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(Object))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
Funu<FunuCyclicCoBound<Function(Function(FutureOr<Object>))>> x176;
//^
// [analyzer] unspecified
-// ^
+// ^
// [cfe] Type argument 'dynamic Function(dynamic Function(FutureOr<Object>))' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
}
@@ -3111,12 +2991,10 @@
FunuCyclicCoBound<Function(Never)> x1;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
FunuCyclicCoBound<Function(N)> x2;
//^
// [analyzer] unspecified
-// ^
// [cfe] Type argument 'dynamic Function(N)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FunuCyclicCoBound'.
}
@@ -3133,8 +3011,6 @@
void f(AinvCyclicCoBound source) {
// ^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
// [cfe] Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
// We do not use `source` in further tests, because the type of `source`
@@ -3146,9 +3022,8 @@
void f(B<AinvCyclicCoBound> source) {
// ^
// [analyzer] unspecified
-// ^
-// [cfe] Type argument 'AinvCyclicCoBound<dynamic Function(Never) Function(dynamic Function(Never)), dynamic Function(Never)>' doesn't conform to the bound 'B<X>' of the type variable 'X' on 'B'.
-// [cfe] Type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(X)' of the type variable 'X' on 'FinvCyclicCoBound'.
+// [cfe] Type argument 'AinvCyclicCoBound<FinvCyclicCoBound<dynamic Function(Never)>, dynamic Function(Never)>' doesn't conform to the bound 'B<X>' of the type variable 'X' on 'B'.
+// ^
// [cfe] Inferred type argument 'dynamic Function(Never)' doesn't conform to the bound 'dynamic Function(Y)' of the type variable 'Y' on 'AinvCyclicCoBound'.
// We do not use `source` in further tests, because the type of `source`
diff --git a/tests/language/generic_methods/generic_function_result_test.dart b/tests/language/generic_methods/generic_function_result_test.dart
index 569c2f9..910c9b4 100644
--- a/tests/language/generic_methods/generic_function_result_test.dart
+++ b/tests/language/generic_methods/generic_function_result_test.dart
@@ -14,17 +14,15 @@
(int i, int j) => i + j;
List<int Function<T>(S, int)> bar<S extends int>() {
+// [error column 1]
+// [cfe] A generic function type can't be used as a type argument.
// ^^^^^^^^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
-// ^
-// [cfe] A generic function type can't be used as a type argument.
return <int Function<T>(S, int)>[foo, foo];
}
void main() {
var list = bar<int>();
- // ^
- // [cfe] Generic function type 'int Function<T>(int, int)' inferred as a type argument.
print(list[0].runtimeType);
Expect.equals(123, list[1](100, 23));
}
diff --git a/tests/language/malbounded/instantiation_test.dart b/tests/language/malbounded/instantiation_test.dart
index 2f397b2..d181b51 100644
--- a/tests/language/malbounded/instantiation_test.dart
+++ b/tests/language/malbounded/instantiation_test.dart
@@ -4,13 +4,13 @@
class Super<T extends num> {}
class Malbounded1 implements Super<String> {}
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
class Malbounded2 extends Super<String> {}
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language/malbounded/type_cast_test.dart b/tests/language/malbounded/type_cast_test.dart
index 2c56e68..e72cb3d 100644
--- a/tests/language/malbounded/type_cast_test.dart
+++ b/tests/language/malbounded/type_cast_test.dart
@@ -6,15 +6,15 @@
class Super<T extends num> {}
class Malbounded1 implements Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
{}
class Malbounded2 extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
@@ -27,7 +27,7 @@
Expect.throwsTypeError(() => s as Malbounded1);
Expect.throwsTypeError(() => s as Malbounded2);
s as Super
- //^
+ // ^
// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
diff --git a/tests/language/malbounded/type_literal_test.dart b/tests/language/malbounded/type_literal_test.dart
index 2369b69..a356615 100644
--- a/tests/language/malbounded/type_literal_test.dart
+++ b/tests/language/malbounded/type_literal_test.dart
@@ -7,8 +7,8 @@
class Super<T extends num> {}
class Malbounded extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language/malbounded/type_test2_test.dart b/tests/language/malbounded/type_test2_test.dart
index 8eec3aa..3ee3e90 100644
--- a/tests/language/malbounded/type_test2_test.dart
+++ b/tests/language/malbounded/type_test2_test.dart
@@ -9,7 +9,7 @@
class B<T> {
test() {
new A() is A
- // ^
+ // ^
// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
<T>
// ^
diff --git a/tests/language/malbounded/type_test_test.dart b/tests/language/malbounded/type_test_test.dart
index 70fc939..c0c61ff 100644
--- a/tests/language/malbounded/type_test_test.dart
+++ b/tests/language/malbounded/type_test_test.dart
@@ -7,16 +7,16 @@
class Super<T extends num> {}
class Malbounded1 implements Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
{}
class Malbounded2 extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
@@ -29,7 +29,7 @@
Expect.isFalse(s is Malbounded1);
Expect.isFalse(s is Malbounded2);
Expect.isTrue(s is Super
- // ^
+ // ^
// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
diff --git a/tests/language/regress/regress18628_2_test.dart b/tests/language/regress/regress18628_2_test.dart
index 622b724..11a1a44 100644
--- a/tests/language/regress/regress18628_2_test.dart
+++ b/tests/language/regress/regress18628_2_test.dart
@@ -13,8 +13,8 @@
// This line is supposed to cause the warning; the other lines are
// marked because they don't make sense when [Y] is not defined.
class Y<U> extends X<U> {}
-// ^
-// [cfe] Type argument 'U' doesn't conform to the bound 'Type' of the type variable 'T' on 'X' in the supertype 'X' of class 'Y'.
+// ^
+// [cfe] Type argument 'U' doesn't conform to the bound 'Type' of the type variable 'T' on 'X'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language/type_variable/bounds3_test.dart b/tests/language/type_variable/bounds3_test.dart
index 471112b..c0482d6 100644
--- a/tests/language/type_variable/bounds3_test.dart
+++ b/tests/language/type_variable/bounds3_test.dart
@@ -9,7 +9,7 @@
class B<X, Y> {
foo(x) {
return x is A<X>;
- // ^
+ // ^
// [cfe] Type argument 'X' doesn't conform to the bound 'int' of the type variable 'K' on 'A'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language/type_variable/bounds4_test.dart b/tests/language/type_variable/bounds4_test.dart
index 9908b9c..e4d5223 100644
--- a/tests/language/type_variable/bounds4_test.dart
+++ b/tests/language/type_variable/bounds4_test.dart
@@ -10,8 +10,8 @@
> {}
class B<T> implements A<T> {}
-// ^
-// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A' in the supertype 'A' of class 'B'.
+// ^
+// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language/variance/variance_in_subtyping_error_test.dart b/tests/language/variance/variance_in_subtyping_error_test.dart
index 4271fd0..1230d2b 100644
--- a/tests/language/variance/variance_in_subtyping_error_test.dart
+++ b/tests/language/variance/variance_in_subtyping_error_test.dart
@@ -41,10 +41,10 @@
class D {
C<Contravariant<Lower>> method1() {
+//^
+// [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C'.
//^^^^^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C' in the return type.
return C<Contravariant<Lower>>();
// ^
// [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C'.
@@ -57,10 +57,10 @@
main() {
C<Contravariant<Lower>> c = new C<Contravariant<Lower>>();
+//^
+// [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C'.
//^^^^^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C'.
// ^
// [cfe] Type argument 'Contravariant<Lower>' doesn't conform to the bound 'Contravariant<Middle>' of the type variable 'T' on 'C'.
// ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/language/variance/variance_inout_subtyping_error_test.dart b/tests/language/variance/variance_inout_subtyping_error_test.dart
index d994e6c..51e9052 100644
--- a/tests/language/variance/variance_inout_subtyping_error_test.dart
+++ b/tests/language/variance/variance_inout_subtyping_error_test.dart
@@ -58,10 +58,10 @@
class E {
D<Invariant<Upper>> method1() {
+//^
+// [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D' in the return type.
return D<Invariant<Upper>>();
// ^
// [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
@@ -70,10 +70,10 @@
}
D<Invariant<Lower>> method2() {
+//^
+// [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D' in the return type.
return D<Invariant<Lower>>();
// ^
// [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
@@ -86,19 +86,19 @@
main() {
D<Invariant<Upper>> dUpper = new D<Invariant<Upper>>();
+//^
+// [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
// ^
// [cfe] Type argument 'Invariant<Upper>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
// ^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
D<Invariant<Lower>> dLower = new D<Invariant<Lower>>();
+//^
+// [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
// ^
// [cfe] Type argument 'Invariant<Lower>' doesn't conform to the bound 'Invariant<Middle>' of the type variable 'T' on 'D'.
// ^^^^^^^^^^^^^^^^
diff --git a/tests/language/variance/variance_out_subtyping_error_test.dart b/tests/language/variance/variance_out_subtyping_error_test.dart
index 2ddcd3e..ecce279 100644
--- a/tests/language/variance/variance_out_subtyping_error_test.dart
+++ b/tests/language/variance/variance_out_subtyping_error_test.dart
@@ -41,10 +41,10 @@
class D {
C<Covariant<Upper>> method1() {
+//^
+// [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C' in the return type.
return C<Covariant<Upper>>();
// ^
// [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C'.
@@ -57,10 +57,10 @@
main() {
C<Covariant<Upper>> c = new C<Covariant<Upper>>();
+//^
+// [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C'.
//^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C'.
// ^
// [cfe] Type argument 'Covariant<Upper>' doesn't conform to the bound 'Covariant<Middle>' of the type variable 'T' on 'C'.
// ^^^^^^^^^^^^^^^^
diff --git a/tests/language_2/generic/f_bounded_quantification_test.dart b/tests/language_2/generic/f_bounded_quantification_test.dart
index 055e05a..7ff3b40 100644
--- a/tests/language_2/generic/f_bounded_quantification_test.dart
+++ b/tests/language_2/generic/f_bounded_quantification_test.dart
@@ -19,10 +19,10 @@
main() {
FBound<Bar> fb = new FBound<Bar>();
FBound<SubBar> fsb = new FBound<SubBar>();
+//^
+// [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^
// [cfe] Type argument 'SubBar' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^
@@ -30,10 +30,10 @@
FBound<Baz<Bar>> fbb = new FBound<Baz<Bar>>();
FBound<SubBaz<Bar>> fsbb = new FBound<SubBaz<Bar>>();
+//^
+// [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
- // ^
- // [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^
// [cfe] Type argument 'SubBaz<Bar>' doesn't conform to the bound 'FBound<F>' of the type variable 'F' on 'FBound'.
// ^^^^^^^^^^^
diff --git a/tests/language_2/generic/function_type_as_type_argument_test.dart b/tests/language_2/generic/function_type_as_type_argument_test.dart
index 130d1b2..6dcc8f7 100644
--- a/tests/language_2/generic/function_type_as_type_argument_test.dart
+++ b/tests/language_2/generic/function_type_as_type_argument_test.dart
@@ -18,17 +18,16 @@
// Generic function types are not allowed as type arguments.
List<T Function<T>(T)> typedList = <T Function<T>(T)>[foo];
- // ^^^^^^^^^^^^^^^^
- // [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
- // ^
- // [cfe] A generic function type can't be used as a type argument.
+//^
+// [cfe] A generic function type can't be used as a type argument.
+// ^^^^^^^^^^^^^^^^
+// [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
// Type inference must also give an error.
var inferredList = [foo];
- // ^
- // [cfe] Generic function type 'T Function<T>(T)' inferred as a type argument.
// ^^^^^
// [analyzer] COMPILE_TIME_ERROR.COULD_NOT_INFER
+ // [cfe] Generic function type 'T Function<T>(T)' inferred as a type argument.
// No error if illegal type cannot be inferred.
var dynamicList = <dynamic>[foo];
diff --git a/tests/language_2/generic_methods/generic_function_result_test.dart b/tests/language_2/generic_methods/generic_function_result_test.dart
index d291d2d..d50dcb5 100644
--- a/tests/language_2/generic_methods/generic_function_result_test.dart
+++ b/tests/language_2/generic_methods/generic_function_result_test.dart
@@ -16,17 +16,15 @@
(int i, int j) => i + j;
List<int Function<T>(S, int)> bar<S extends int>() {
+// [error column 1]
+// [cfe] A generic function type can't be used as a type argument.
// ^^^^^^^^^^^^^^^^^^^^^^^
// [analyzer] COMPILE_TIME_ERROR.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT
-// ^
-// [cfe] A generic function type can't be used as a type argument.
return <int Function<T>(S, int)>[foo, foo];
}
void main() {
var list = bar<int>();
- // ^
- // [cfe] Generic function type 'int Function<T>(int, int)' inferred as a type argument.
print(list[0].runtimeType);
Expect.equals(123, list[1](100, 23));
}
diff --git a/tests/language_2/malbounded/instantiation_test.dart b/tests/language_2/malbounded/instantiation_test.dart
index 9f52427..b3f0bfa 100644
--- a/tests/language_2/malbounded/instantiation_test.dart
+++ b/tests/language_2/malbounded/instantiation_test.dart
@@ -6,13 +6,13 @@
class Super<T extends num> {}
class Malbounded1 implements Super<String> {}
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
class Malbounded2 extends Super<String> {}
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language_2/malbounded/type_cast_test.dart b/tests/language_2/malbounded/type_cast_test.dart
index 476c63e..7e98c55 100644
--- a/tests/language_2/malbounded/type_cast_test.dart
+++ b/tests/language_2/malbounded/type_cast_test.dart
@@ -8,15 +8,15 @@
class Super<T extends num> {}
class Malbounded1 implements Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
{}
class Malbounded2 extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
@@ -29,7 +29,7 @@
Expect.throwsTypeError(() => s as Malbounded1);
Expect.throwsTypeError(() => s as Malbounded2);
s as Super
- //^
+ // ^
// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
diff --git a/tests/language_2/malbounded/type_literal_test.dart b/tests/language_2/malbounded/type_literal_test.dart
index ebfef5b..eb4a34c 100644
--- a/tests/language_2/malbounded/type_literal_test.dart
+++ b/tests/language_2/malbounded/type_literal_test.dart
@@ -9,8 +9,8 @@
class Super<T extends num> {}
class Malbounded extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language_2/malbounded/type_test2_test.dart b/tests/language_2/malbounded/type_test2_test.dart
index 542b7f6..0e4cb69 100644
--- a/tests/language_2/malbounded/type_test2_test.dart
+++ b/tests/language_2/malbounded/type_test2_test.dart
@@ -11,7 +11,7 @@
class B<T> {
test() {
new A() is A
- // ^
+ // ^
// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
<T>
// ^
diff --git a/tests/language_2/malbounded/type_test_test.dart b/tests/language_2/malbounded/type_test_test.dart
index b5434fd..c312857 100644
--- a/tests/language_2/malbounded/type_test_test.dart
+++ b/tests/language_2/malbounded/type_test_test.dart
@@ -9,16 +9,16 @@
class Super<T extends num> {}
class Malbounded1 implements Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded1'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
{}
class Malbounded2 extends Super
-// ^
-// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super' in the supertype 'Super' of class 'Malbounded2'.
+// ^
+// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
@@ -31,7 +31,7 @@
Expect.isFalse(s is Malbounded1);
Expect.isFalse(s is Malbounded2);
Expect.isTrue(s is Super
- // ^
+ // ^
// [cfe] Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'Super'.
<String>
// ^^^^^^
diff --git a/tests/language_2/regress/regress18628_2_test.dart b/tests/language_2/regress/regress18628_2_test.dart
index 85d59ca..e035c81 100644
--- a/tests/language_2/regress/regress18628_2_test.dart
+++ b/tests/language_2/regress/regress18628_2_test.dart
@@ -15,8 +15,8 @@
// This line is supposed to cause the warning; the other lines are
// marked because they don't make sense when [Y] is not defined.
class Y<U> extends X<U> {}
-// ^
-// [cfe] Type argument 'U' doesn't conform to the bound 'Type' of the type variable 'T' on 'X' in the supertype 'X' of class 'Y'.
+// ^
+// [cfe] Type argument 'U' doesn't conform to the bound 'Type' of the type variable 'T' on 'X'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language_2/type_variable/bounds3_test.dart b/tests/language_2/type_variable/bounds3_test.dart
index a56675e..7246ac7 100644
--- a/tests/language_2/type_variable/bounds3_test.dart
+++ b/tests/language_2/type_variable/bounds3_test.dart
@@ -11,7 +11,7 @@
class B<X, Y> {
foo(x) {
return x is A<X>;
- // ^
+ // ^
// [cfe] Type argument 'X' doesn't conform to the bound 'int' of the type variable 'K' on 'A'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tests/language_2/type_variable/bounds4_test.dart b/tests/language_2/type_variable/bounds4_test.dart
index 265c94f0..9fa6558 100644
--- a/tests/language_2/type_variable/bounds4_test.dart
+++ b/tests/language_2/type_variable/bounds4_test.dart
@@ -12,8 +12,8 @@
> {}
class B<T> implements A<T> {}
-// ^
-// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A' in the supertype 'A' of class 'B'.
+// ^
+// [cfe] Type argument 'T' doesn't conform to the bound 'num' of the type variable 'T' on 'A'.
// ^
// [analyzer] COMPILE_TIME_ERROR.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
diff --git a/tools/VERSION b/tools/VERSION
index 0ba49e7..0b55526 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 18
PATCH 0
-PRERELEASE 125
+PRERELEASE 126
PRERELEASE_PATCH 0
\ No newline at end of file
