[cfe] Check bounds for mutual subtyping in generic method overrides

Closes #40479

Bug: http://dartbug.com/40479
Change-Id: Ie98c4d316caa14ab51d838a05b1a2167024ce372
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/135061
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Dmitry Stefantsov <[email protected]>

Author: Dmitry Stefantsov

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

@@ -678,7 +678,9 @@ class ClassHierarchyNodeBuilder {
       for (int i = 0; i < typeParameterCount; i++) {
         DartType aBound = aTypeParameters[i].bound;
         DartType bBound = substitution.substituteType(bTypeParameters[i].bound);
-        if (aBound != bBound) {
+        if (!hierarchy.types
+            .isSameTypeKernel(aBound, bBound)
+            .isSubtypeWhenUsingNullabilities()) {
           debug?.log("Giving up 3");
           return false;
         }

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart

@@ -0,0 +1,20 @@
+// 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.
+
+// @dart = 2.6
+
+// This test checks that when a generic method from an opted-in library is
+// overridden by a method from an opted-out library, the bounds are checked to
+// be mutual subtypes, and not for equality.  Otherwise, it would be impossible
+// to override a generic method with a default bound with another generic method
+// with a default bound.
+
+import './mixed_mode_hierarchy_generic_methods_lib.dart';
+import "dart:async";
+
+class B implements A<int> {
+  then<B>() => Future<B>.value();
+}
+
+main() {}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart.outline.expect

@@ -0,0 +1,29 @@
+library;
+import self as self;
+import "dart:core" as core;
+import "mixed_mode_hierarchy_generic_methods_lib.dart" as mix;
+import "dart:async" as asy;
+
+import "org-dartlang-testcase:///mixed_mode_hierarchy_generic_methods_lib.dart";
+import "dart:async";
+
+class B extends core::Object implements mix::A<core::int*> {
+  synthetic constructor •() → self::B*
+    ;
+  method then<B extends core::Object* = dynamic>() → asy::Future<self::B::then::B%>
+    ;
+}
+static method main() → dynamic
+  ;
+
+library /*isNonNullableByDefault*/;
+import self as mix;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+class A<R extends core::Object? = dynamic> extends core::Object {
+  synthetic constructor •() → mix::A<mix::A::R%>
+    ;
+  method then<T extends core::Object? = dynamic>() → asy::Future<mix::A::then::T%>
+    ;
+}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart.strong.expect

@@ -0,0 +1,30 @@
+library;
+import self as self;
+import "dart:core" as core;
+import "mixed_mode_hierarchy_generic_methods_lib.dart" as mix;
+import "dart:async" as asy;
+
+import "org-dartlang-testcase:///mixed_mode_hierarchy_generic_methods_lib.dart";
+import "dart:async";
+
+class B extends core::Object implements mix::A<core::int*> {
+  synthetic constructor •() → self::B*
+    : super core::Object::•()
+    ;
+  method then<B extends core::Object* = dynamic>() → asy::Future<self::B::then::B%>
+    return asy::Future::value<self::B::then::B*>();
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mix;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+class A<R extends core::Object? = dynamic> extends core::Object {
+  synthetic constructor •() → mix::A<mix::A::R%>
+    : super core::Object::•()
+    ;
+  method then<T extends core::Object? = dynamic>() → asy::Future<mix::A::then::T%>
+    return asy::Future::value<mix::A::then::T%>();
+}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart.strong.transformed.expect

@@ -0,0 +1,30 @@
+library;
+import self as self;
+import "dart:core" as core;
+import "mixed_mode_hierarchy_generic_methods_lib.dart" as mix;
+import "dart:async" as asy;
+
+import "org-dartlang-testcase:///mixed_mode_hierarchy_generic_methods_lib.dart";
+import "dart:async";
+
+class B extends core::Object implements mix::A<core::int*> {
+  synthetic constructor •() → self::B*
+    : super core::Object::•()
+    ;
+  method then<B extends core::Object* = dynamic>() → asy::Future<self::B::then::B%>
+    return asy::Future::value<self::B::then::B*>();
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mix;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+class A<R extends core::Object? = dynamic> extends core::Object {
+  synthetic constructor •() → mix::A<mix::A::R%>
+    : super core::Object::•()
+    ;
+  method then<T extends core::Object? = dynamic>() → asy::Future<mix::A::then::T%>
+    return asy::Future::value<mix::A::then::T%>();
+}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart.weak.expect

@@ -0,0 +1,30 @@
+library;
+import self as self;
+import "dart:core" as core;
+import "mixed_mode_hierarchy_generic_methods_lib.dart" as mix;
+import "dart:async" as asy;
+
+import "org-dartlang-testcase:///mixed_mode_hierarchy_generic_methods_lib.dart";
+import "dart:async";
+
+class B extends core::Object implements mix::A<core::int*> {
+  synthetic constructor •() → self::B*
+    : super core::Object::•()
+    ;
+  method then<B extends core::Object* = dynamic>() → asy::Future<self::B::then::B%>
+    return asy::Future::value<self::B::then::B*>();
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mix;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+class A<R extends core::Object? = dynamic> extends core::Object {
+  synthetic constructor •() → mix::A<mix::A::R%>
+    : super core::Object::•()
+    ;
+  method then<T extends core::Object? = dynamic>() → asy::Future<mix::A::then::T%>
+    return asy::Future::value<mix::A::then::T%>();
+}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods.dart.weak.transformed.expect

@@ -0,0 +1,30 @@
+library;
+import self as self;
+import "dart:core" as core;
+import "mixed_mode_hierarchy_generic_methods_lib.dart" as mix;
+import "dart:async" as asy;
+
+import "org-dartlang-testcase:///mixed_mode_hierarchy_generic_methods_lib.dart";
+import "dart:async";
+
+class B extends core::Object implements mix::A<core::int*> {
+  synthetic constructor •() → self::B*
+    : super core::Object::•()
+    ;
+  method then<B extends core::Object* = dynamic>() → asy::Future<self::B::then::B%>
+    return asy::Future::value<self::B::then::B*>();
+}
+static method main() → dynamic {}
+
+library /*isNonNullableByDefault*/;
+import self as mix;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+class A<R extends core::Object? = dynamic> extends core::Object {
+  synthetic constructor •() → mix::A<mix::A::R%>
+    : super core::Object::•()
+    ;
+  method then<T extends core::Object? = dynamic>() → asy::Future<mix::A::then::T%>
+    return asy::Future::value<mix::A::then::T%>();
+}

pkg/front_end/testcases/nnbd/mixed_mode_hierarchy_generic_methods_lib.dart

@@ -0,0 +1,7 @@
+// 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.
+
+class A<R> {
+  Future<T> then<T>() => Future<T>.value();
+}

pkg/front_end/testcases/text_serialization.status

@@ -1243,6 +1243,7 @@ nnbd/member_inheritance_from_opt_out: TextSerializationFailure
 nnbd/messages_with_types_opt_in: TypeCheckError
 nnbd/messages_with_types_opt_out: TypeCheckError
 nnbd/missing_required_named_parameter: TextSerializationFailure
+nnbd/mixed_mode_hierarchy_generic_methods: TextSerializationFailure
 nnbd/mixin_from_opt_in: TextSerializationFailure
 nnbd/mixin_from_opt_out: TextSerializationFailure
 nnbd/never_opt_out: TypeCheckError