Report CONFLICTING_GENERIC_INTERFACES using ClassHierarchy.

Change-Id: Ib5d79403358efffd5365ac4931c3163d746d933a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142567
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

pkg/_fe_analyzer_shared/test/inheritance/data/in_out_in/main.dart

@@ -17,32 +17,26 @@ class SubClass2 extends LegacyClass2 implements Interface {
   /*member: SubClass2.method:int? Function(int)*/
 }
 
-// TODO: Solve CFE / analyzer difference.
-// This an following examples end up with implementing `GenericInterface`
-// with `int` and `int?` type arguments, and their NNBD_TOP_MERGE does not
-// exist. it does not matter that some of these interfaces come through a
-// legacy library.
-
 /*class: GenericSubClass1a:GenericClass1,GenericInterface<int?>,GenericLegacyClass1a,GenericSubClass1a,Object*/
-/*analyzer.error: CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES*/ abstract class GenericSubClass1a
-    extends GenericLegacyClass1a implements GenericInterface<int?> {
+abstract class GenericSubClass1a extends GenericLegacyClass1a
+    implements GenericInterface<int?> {
   /*member: GenericSubClass1a.method:int? Function(int?)*/
 }
 
 /*class: GenericSubClass1b:GenericClass1,GenericInterface<int?>,GenericLegacyClass1b,GenericSubClass1b,Object*/
-/*analyzer.error: CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES*/ abstract class GenericSubClass1b
-    extends GenericLegacyClass1b implements GenericInterface<int?> {
+abstract class GenericSubClass1b extends GenericLegacyClass1b
+    implements GenericInterface<int?> {
   /*member: GenericSubClass1b.method:int? Function(int?)*/
 }
 
 /*class: GenericSubClass2a:GenericClass2,GenericInterface<int>,GenericLegacyClass2a,GenericSubClass2a,Object*/
-/*analyzer.error: CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES*/ abstract class GenericSubClass2a
-    extends GenericLegacyClass2a implements GenericInterface<int> {
+abstract class GenericSubClass2a extends GenericLegacyClass2a
+    implements GenericInterface<int> {
   /*member: GenericSubClass2a.method:int Function(int)*/
 }
 
 /*class: GenericSubClass2b:GenericClass2,GenericInterface<int>,GenericLegacyClass2b,GenericSubClass2b,Object*/
-/*analyzer.error: CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES*/ abstract class GenericSubClass2b
-    extends GenericLegacyClass2b implements GenericInterface<int> {
+abstract class GenericSubClass2b extends GenericLegacyClass2b
+    implements GenericInterface<int> {
   /*member: GenericSubClass2b.method:int Function(int)*/
 }

pkg/_fe_analyzer_shared/test/inheritance/data/in_out_in/opt_out.dart

@@ -18,8 +18,6 @@ abstract class LegacyClass2 extends Class {
   /*member: LegacyClass2.method:int* Function(int*)**/
 }
 
-/// TODO: Solve CFE / analyzer difference.
-/// Classes in legacy libraries can only have members with legacy signatures.
 /*class: GenericLegacyClass1a:GenericClass1,GenericInterface<int*>,GenericLegacyClass1a,Object*/
 abstract class GenericLegacyClass1a extends GenericClass1 {
   /*member: GenericLegacyClass1a.method:int* Function(int*)**/

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

@@ -15,10 +15,11 @@ import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/src/dart/analysis/session.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/class_hierarchy.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
-import 'package:analyzer/src/dart/element/nullability_eliminator.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/variance.dart';
 import 'package:analyzer/src/diagnostic/diagnostic_factory.dart';
@@ -1957,58 +1958,26 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   }
 
   void _checkForConflictingGenerics(NamedCompilationUnitMember node) {
-    var visitedClasses = <ClassElement>[];
-    var interfaces = <ClassElement, InterfaceType>{};
-
-    void visit(InterfaceType type) {
-      if (type == null) return;
-
-      var element = type.element;
-      if (visitedClasses.contains(element)) return;
-      visitedClasses.add(element);
-
-      if (element.typeParameters.isNotEmpty) {
-        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],
-            );
-          }
-        }
-      }
+    var element = node.declaredElement as ClassElement;
 
-      visit(type.superclass);
-      type.mixins.forEach(visit);
-      type.superclassConstraints.forEach(visit);
-      type.interfaces.forEach(visit);
+    var analysisSession = _currentLibrary.session as AnalysisSessionImpl;
+    var errors = analysisSession.classHierarchy.errors(element);
 
-      visitedClasses.removeLast();
+    for (var error in errors) {
+      if (error is IncompatibleInterfacesClassHierarchyError) {
+        _errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES,
+          node,
+          [
+            _enclosingClass.name,
+            error.first.getDisplayString(withNullability: true),
+            error.second.getDisplayString(withNullability: true),
+          ],
+        );
+      } else {
+        throw UnimplementedError('${error.runtimeType}');
+      }
     }
-
-    visit(_enclosingClass.thisType);
   }
 
   /**
@@ -5552,13 +5521,6 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     return null;
   }
 
-  /// If in a legacy library, return the legacy version of the [type].
-  /// Otherwise, return the original type.
-  DartType _toLegacyType(DartType type) {
-    if (_isNonNullableByDefault) return type;
-    return NullabilityEliminator.perform(_typeProvider, type);
-  }
-
   /**
    * Return [FieldElement]s that are declared in the [ClassDeclaration] with
    * the given [constructor], but are not initialized.

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

@@ -125,6 +125,30 @@ class C extends B implements A<int> {}
 ''');
   }
 
+  test_class_mixed_viaLegacy() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A<T> {}
+
+class Bi implements A<int> {}
+
+class Biq implements A<int?> {}
+''');
+
+    // Both `Bi` and `Biq` implement `A<int*>` in legacy, so identical.
+    newFile('/test/lib/b.dart', content: r'''
+// @dart = 2.7
+import 'a.dart';
+
+class C extends Bi implements Biq {}
+''');
+
+    await assertNoErrorsInCode(r'''
+import 'b.dart';
+
+abstract class D implements C {}
+''');
+  }
+
   test_class_topMerge() async {
     await assertNoErrorsInCode('''
 import 'dart:async';