[cfe] Normalize supertypes before nnbd-top-merging them

Closes #40454.

Bug: http://dartbug.com/40454
Change-Id: Ia255c99c937a04876e04a0f0f5935147e55fbd35
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/134842
Reviewed-by: Johnni Winther <[email protected]>

Author: Dmitry Stefantsov

pkg/_fe_analyzer_shared/test/inheritance/data/norm_supertypes.dart

@@ -0,0 +1,30 @@
+// Copyright (c) 2020, 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.
+
+/*library: nnbd=true*/
+
+import 'dart:async';
+
+/*class: A:A<T>,Object*/
+class A<T> {}
+
+/*class: Foo:A<FutureOr<T?>!>,Foo<T!,S!>,Object*/
+class Foo<T extends S, S extends Never> implements A<FutureOr<T?>> {}
+
+/*class: Bar:A<FutureOr<Never>!>,Bar,Object*/
+class Bar implements A<FutureOr<Never?>> {}
+
+/*class: Baz:A<Future<Null>?>,Baz,Object*/
+class Baz implements A<Future<Null>?> {}
+
+/*class: Hest:A<Future<Null>?>,Bar,Foo<Never,Never>,Hest,Object*/
+class Hest extends Foo implements Bar {}
+
+/*class: Fisk:A<Future<Null>?>,Bar,Baz,Fisk,Object*/
+class Fisk extends Bar implements Baz {}
+
+/*class: Naebdyr:A<Future<Null>?>,Baz,Foo<Never,Never>,Naebdyr,Object*/
+class Naebdyr extends Baz implements Foo {}
+
+main() {}

pkg/front_end/lib/src/fasta/kernel/class_hierarchy_builder.dart

@@ -16,6 +16,7 @@ import 'package:kernel/type_environment.dart';
 import 'package:kernel/src/future_or.dart';
 import 'package:kernel/src/legacy_erasure.dart';
 import 'package:kernel/src/nnbd_top_merge.dart';
+import 'package:kernel/src/norm.dart';
 
 import '../../testing/id_testing_utils.dart' show typeToText;
 
@@ -1536,7 +1537,10 @@ class ClassHierarchyNodeBuilder {
           superclass.classNode == type.classNode) {
         // This is a potential conflict.
         if (classBuilder.library.isNonNullableByDefault) {
-          superclass = nnbdTopMerge(hierarchy.coreTypes, superclass, type);
+          superclass = nnbdTopMerge(
+              hierarchy.coreTypes,
+              norm(hierarchy.coreTypes, superclass),
+              norm(hierarchy.coreTypes, type));
           if (superclass == null) {
             // This is a conflict.
             // TODO(johnniwinther): Report errors here instead of through
@@ -1556,7 +1560,10 @@ class ClassHierarchyNodeBuilder {
               interface.classNode == type.classNode) {
             // This is a potential conflict.
             if (classBuilder.library.isNonNullableByDefault) {
-              interface = nnbdTopMerge(hierarchy.coreTypes, interface, type);
+              interface = nnbdTopMerge(
+                  hierarchy.coreTypes,
+                  norm(hierarchy.coreTypes, interface),
+                  norm(hierarchy.coreTypes, type));
               if (interface == null) {
                 // This is a conflict.
                 // TODO(johnniwinther): Report errors here instead of through

pkg/front_end/test/id_tests/inheritance_test.dart

@@ -28,8 +28,7 @@ main(List<String> args) async {
             experimentalFlags: const {ExperimentalFlag.nonNullable: true},
             librariesSpecificationUri: createUriForFileName('libraries.json'),
             compileSdk: true),
-        new TestConfig(
-            cfeFromBuilderMarker, 'cfe from builder',
+        new TestConfig(cfeFromBuilderMarker, 'cfe from builder',
             experimentalFlags: const {ExperimentalFlag.nonNullable: true},
             librariesSpecificationUri: createUriForFileName('libraries.json'),
             compileSdk: true)

pkg/kernel/lib/class_hierarchy.dart

@@ -15,6 +15,7 @@ import 'type_algebra.dart';
 import 'src/future_or.dart';
 import 'src/heap.dart';
 import 'src/legacy_erasure.dart';
+import 'src/norm.dart';
 
 typedef HandleAmbiguousSupertypes = void Function(Class, Supertype, Supertype);
 
@@ -1581,7 +1582,10 @@ class _ClassInfo {
       genericSuperTypes[cls].add(type);
 
       if (classNode.enclosingLibrary.isNonNullableByDefault) {
-        Supertype result = nnbdTopMergeSupertype(coreTypes, type, canonical);
+        Supertype result = nnbdTopMergeSupertype(
+            coreTypes,
+            normSupertype(coreTypes, type),
+            normSupertype(coreTypes, canonical));
         if (result == null) {
           onAmbiguousSupertypes(classNode, canonical, type);
         } else {

pkg/kernel/lib/src/norm.dart

@@ -13,6 +13,21 @@ DartType norm(CoreTypes coreTypes, DartType type) {
   return type.accept(new _Norm(coreTypes)) ?? type;
 }
 
+Supertype normSupertype(CoreTypes coreTypes, Supertype supertype) {
+  if (supertype.typeArguments.isEmpty) return supertype;
+  _Norm normVisitor = new _Norm(coreTypes);
+  List<DartType> typeArguments = null;
+  for (int i = 0; i < supertype.typeArguments.length; ++i) {
+    DartType typeArgument = supertype.typeArguments[i].accept(normVisitor);
+    if (typeArgument != null) {
+      typeArguments ??= supertype.typeArguments.toList();
+      typeArguments[i] = typeArgument;
+    }
+  }
+  if (typeArguments == null) return supertype;
+  return new Supertype(supertype.classNode, typeArguments);
+}
+
 /// Visitor implementing the NORM algorithm.
 ///
 /// Visitor's methods return null if the type is unchanged by the NORM