Break cycles in type parameters during linking.

Change-Id: Ibb31d2e1e4ea61451c6fff6c248938a7df333dea
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155061
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/summary2/default_types_builder.dart

@@ -19,22 +19,27 @@ class DefaultTypesBuilder {
     for (var node in nodes) {
       if (node is ClassDeclaration) {
         var element = node.declaredElement;
+        _breakSelfCycles(node.typeParameters);
         _breakRawTypeCycles(element, node.typeParameters);
         _computeBounds(element, node.typeParameters);
       } else if (node is ClassTypeAlias) {
         var element = node.declaredElement;
+        _breakSelfCycles(node.typeParameters);
         _breakRawTypeCycles(element, node.typeParameters);
         _computeBounds(element, node.typeParameters);
       } else if (node is FunctionTypeAlias) {
         var element = node.declaredElement;
+        _breakSelfCycles(node.typeParameters);
         _breakRawTypeCycles(element, node.typeParameters);
         _computeBounds(element, node.typeParameters);
       } else if (node is GenericTypeAlias) {
         var element = node.declaredElement;
+        _breakSelfCycles(node.typeParameters);
         _breakRawTypeCycles(element, node.typeParameters);
         _computeBounds(element, node.typeParameters);
       } else if (node is MixinDeclaration) {
         var element = node.declaredElement;
+        _breakSelfCycles(node.typeParameters);
         _breakRawTypeCycles(element, node.typeParameters);
         _computeBounds(element, node.typeParameters);
       }
@@ -86,6 +91,45 @@ class DefaultTypesBuilder {
     }
   }
 
+  void _breakSelfCycles(TypeParameterList parameterList) {
+    if (parameterList == null) return;
+    var typeParameters = parameterList.typeParameters;
+
+    Map<String, TypeParameter> typeParametersByName;
+    for (var parameter in typeParameters) {
+      var boundNode = parameter.bound;
+      if (boundNode is TypeName) {
+        if (typeParametersByName == null) {
+          typeParametersByName = {};
+          for (var parameterNode in typeParameters) {
+            var name = parameterNode.name.name;
+            typeParametersByName[name] = parameterNode;
+          }
+        }
+
+        var current = parameter;
+        for (var step = 0;
+            current != null && step < typeParameters.length;
+            ++step) {
+          var bound = current.bound;
+          if (bound is TypeName) {
+            var typeNameIdentifier = bound.name;
+            if (typeNameIdentifier is SimpleIdentifier) {
+              current = typeParametersByName[typeNameIdentifier.name];
+              continue;
+            }
+          }
+          current = null;
+          break;
+        }
+
+        if (current != null) {
+          boundNode.type = DynamicTypeImpl.instance;
+        }
+      }
+    }
+  }
+
   /// Build actual default type [DartType]s from computed [TypeBuilder]s.
   void _build(TypeParameterList parameterList) {
     if (parameterList == null) return;

pkg/analyzer/test/src/diagnostics/type_parameter_supertype_of_its_bound_test.dart

@@ -6,10 +6,12 @@ import 'package:analyzer/src/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../dart/resolution/driver_resolution.dart';
+import '../dart/resolution/with_null_safety_mixin.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TypeParameterSupertypeOfItsBoundTest);
+    defineReflectiveTests(TypeParameterSupertypeOfItsBoundWithNullSafetyTest);
   });
 }
 
@@ -24,6 +26,18 @@ class A<T extends T> {
     ]);
   }
 
+  test_1of1_used() async {
+    await assertErrorsInCode('''
+class A<T extends T> {
+  void foo(x) {
+    x is T;
+  }
+}
+''', [
+      error(StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, 8, 11),
+    ]);
+  }
+
   test_2of3() async {
     await assertErrorsInCode(r'''
 class A<T1 extends T3, T2, T3 extends T1> {
@@ -35,3 +49,7 @@ class A<T1 extends T3, T2, T3 extends T1> {
     ]);
   }
 }
+
+@reflectiveTest
+class TypeParameterSupertypeOfItsBoundWithNullSafetyTest
+    extends TypeParameterSupertypeOfItsBoundTest with WithNullSafetyMixin {}

pkg/analyzer/test/src/summary/resynthesize_common.dart

@@ -1685,6 +1685,30 @@ class D {
 ''');
   }
 
+  test_class_type_parameters_cycle_1of1() async {
+    var library = await checkLibrary('class C<T extends T> {}');
+    checkElementText(
+        library,
+        r'''
+notSimplyBounded class C<T extends dynamic> {
+}
+''',
+        withTypes: true);
+  }
+
+  test_class_type_parameters_cycle_2of3() async {
+    var library = await checkLibrary(r'''
+class C<T extends V, U, V extends T> {}
+''');
+    checkElementText(
+        library,
+        r'''
+notSimplyBounded class C<T extends dynamic, U, V extends dynamic> {
+}
+''',
+        withTypes: true);
+  }
+
   test_class_type_parameters_f_bound_complex() async {
     var library = await checkLibrary('class C<T extends List<U>, U> {}');
     checkElementText(library, r'''