Issue 40221. NNBD_TOP_MERGE super-interfaces when checking for implementing the same generic class more than once.

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

Author: scheglov

pkg/analyzer/lib/src/dart/element/normalize.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 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ -19,6 +20,8 @@ class NormalizeHelper {
   final TypeSystemImpl typeSystem;
   final TypeProviderImpl typeProvider;
 
+  final Set<TypeParameterElement> _typeParameters = {};
+
   NormalizeHelper(this.typeSystem) : typeProvider = typeSystem.typeProvider;
 
   DartType normalize(DartType T) {
@@ -242,7 +245,13 @@ class NormalizeHelper {
     }
 
     // * let S be NORM(T)
-    var S = _normalize(bound);
+    DartType S;
+    if (_typeParameters.add(element)) {
+      S = _normalize(bound);
+      _typeParameters.remove(element);
+    } else {
+      return T;
+    }
 
     // * if S is Never then Never
     if (identical(S, NeverTypeImpl.instance)) {

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -1967,16 +1967,35 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
       visitedClasses.add(element);
 
       if (element.typeParameters.isNotEmpty) {
-        type = _toLegacyType(type);
-        var oldType = interfaces[element];
-        if (oldType == null) {
-          interfaces[element] = type;
-        } else if (type != oldType) {
-          _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES,
-            node,
-            [_enclosingClass.name, oldType, type],
-          );
+        if (_typeSystem.isNonNullableByDefault) {
+          type = _typeSystem.normalize(type);
+          var oldType = interfaces[element];
+          if (oldType == null) {
+            interfaces[element] = type;
+          } else {
+            try {
+              var result = _typeSystem.topMerge(oldType, type);
+              interfaces[element] = result;
+            } catch (_) {
+              _errorReporter.reportErrorForNode(
+                CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES,
+                node,
+                [_enclosingClass.name, oldType, type],
+              );
+            }
+          }
+        } else {
+          type = _toLegacyType(type);
+          var oldType = interfaces[element];
+          if (oldType == null) {
+            interfaces[element] = type;
+          } else if (type != oldType) {
+            _errorReporter.reportErrorForNode(
+              CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES,
+              node,
+              [_enclosingClass.name, oldType, type],
+            );
+          }
         }
       }
 

pkg/analyzer/test/src/dart/element/normalize_type_test.dart

@@ -404,6 +404,12 @@ class NormalizeTypeTest with ElementsTypesMixin {
     _check(typeParameterTypeNone(T), typeParameterTypeNone(T));
   }
 
+  test_typeParameter_bound_recursive() {
+    var T = typeParameter('T');
+    T.bound = iterableNone(typeParameterTypeNone(T));
+    _check(typeParameterTypeNone(T), typeParameterTypeNone(T));
+  }
+
   test_typeParameter_promoted() {
     var T = typeParameter('T');
 

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

@@ -121,6 +121,38 @@ class B extends A<int> {}
 // @dart = 2.5
 import 'a.dart';
 
+class C extends B implements A<int> {}
+''');
+  }
+
+  test_class_topMerge() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+class A<T> {}
+
+class B extends A<FutureOr<Object>> {}
+
+class C extends B implements A<Object> {}
+''');
+  }
+
+  test_class_topMerge_optIn_optOut() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A<T> {}
+''');
+
+    newFile('/test/lib/b.dart', content: r'''
+// @dart = 2.5
+import 'a.dart';
+
+class B extends A<int> {}
+''');
+
+    await assertNoErrorsInCode('''
+import 'a.dart';
+import 'b.dart';
+
 class C extends B implements A<int> {}
 ''');
   }