Add language tests illustrating issue #42603.

Bug: #42603
Change-Id: I1d59b7b65d77e5f1accb4f9c3c99e92e48ffb364
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/153709
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Bob Nystrom <[email protected]>

Author: stereotype441

tests/language/nnbd/static_errors/super_equals_allows_null_test.dart

@@ -0,0 +1,97 @@
+// 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.
+import "package:expect/expect.dart";
+
+// SharedOptions=--enable-experiment=non-nullable
+
+// Test that `super == x` is allowed when `x` has a nullable type, even if the
+// targeted definition of `operator==` has a parameter with a non-nullable type,
+// as per this spec text (from
+// accepted/future-releases/nnbd/feature-specification.md):
+//
+//     Similarly, consider an expression `e` of the form `super == e2` that
+//     occurs in a class whose superclass is `C`, where the static type of `e2`
+//     is `T2`. Let `S` be the formal parameter type of the concrete declaration
+//     of `operator ==` found by method lookup in `C` (_if that search succeeds,
+//     otherwise it is a compile-time error_).  It is a compile-time error
+//     unless `T2` is assignable to `S?`.
+//
+// Also test that `super == null` evaluates to `false` without calling
+// `super.operator==`, as per this spec text (from section "Equality"):
+//
+//     Evaluation of an equality expression ee of the form super == e proceeds
+//     as follows:
+//     - The expression e is evaluated to an object o.
+//     - If either this or o is the null object (16.4), then ee evaluates to
+//       evaluates to true if both this and o are the null object and to false
+//       otherwise.  Otherwise,
+//     - evaluation of ee is equivalent to the method invocation super.==(o).
+
+MapEntry<dynamic, dynamic>? _call = null;
+
+class BaseObject {
+  bool operator ==(Object other) {
+    Expect.isNull(_call);
+    _call = MapEntry(this, other);
+    return false;
+  }
+}
+
+class DerivedObject extends BaseObject {
+  void test() {
+    Object? nullAsObjectQuestion = null;
+    Object? nonNullAsObjectQuestion = 0;
+    dynamic nullAsDynamic = null;
+    dynamic nonNullAsDynamic = 1;
+    Expect.isFalse(super == nullAsObjectQuestion);
+    Expect.isNull(_call);
+    Expect.isFalse(super == nonNullAsObjectQuestion);
+    Expect.identical(_call!.key, this);
+    Expect.identical(_call!.value, nonNullAsObjectQuestion);
+    _call = null;
+    Expect.isFalse(super == nullAsDynamic);
+    Expect.isNull(_call);
+    Expect.isFalse(super == nonNullAsDynamic);
+    Expect.identical(_call!.key, this);
+    Expect.identical(_call!.value, nonNullAsDynamic);
+    _call = null;
+  }
+}
+
+class BaseNum {
+  bool operator ==(covariant num other) {
+    Expect.isNull(_call);
+    _call = MapEntry(this, other);
+    return false;
+  }
+}
+
+class DerivedNum extends BaseNum {
+  void test() {
+    num? nullAsNumQuestion = null;
+    num? nonNullAsNumQuestion = 0;
+    dynamic nullAsDynamic = null;
+    dynamic nonNullAsDynamic = 1;
+    dynamic nonNumAsDynamic = 'foo';
+    Expect.isFalse(super == nullAsNumQuestion);
+    Expect.isNull(_call);
+    Expect.isFalse(super == nonNullAsNumQuestion);
+    Expect.identical(_call!.key, this);
+    Expect.identical(_call!.value, nonNullAsNumQuestion);
+    _call = null;
+    Expect.isFalse(super == nullAsDynamic);
+    Expect.isNull(_call);
+    Expect.isFalse(super == nonNullAsDynamic);
+    Expect.identical(_call!.key, this);
+    Expect.identical(_call!.value, nonNullAsDynamic);
+    _call = null;
+    Expect.throwsTypeError(() => super == nonNumAsDynamic);
+    Expect.isNull(_call);
+  }
+}
+
+main() {
+  DerivedObject().test();
+  DerivedNum().test();
+}

tests/language/nnbd/static_errors/super_equals_disallows_non_matching_type_error_test.dart

@@ -0,0 +1,37 @@
+// 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.
+import "package:expect/expect.dart";
+
+// SharedOptions=--enable-experiment=non-nullable
+
+// Test that `super == x` is properly type checked against the target
+// `operator==` method.  That is, the special allowance in the following spec
+// text (from accepted/future-releases/nnbd/feature-specification.md) allows `x`
+// to be nullable, but still requires that the type otherwise matches:
+//
+//     Similarly, consider an expression `e` of the form `super == e2` that
+//     occurs in a class whose superclass is `C`, where the static type of `e2`
+//     is `T2`. Let `S` be the formal parameter type of the concrete declaration
+//     of `operator ==` found by method lookup in `C` (_if that search succeeds,
+//     otherwise it is a compile-time error_).  It is a compile-time error
+//     unless `T2` is assignable to `S?`.
+
+class Base {
+  bool operator ==(covariant num other) => false;
+}
+
+class Derived extends Base {
+  void test() {
+    String string = 'foo';
+    String? stringQuestion = 'foo';
+    super == string;
+    //       ^^^^^^
+    // [analyzer] STATIC_WARNING.ARGUMENT_TYPE_NOT_ASSIGNABLE
+    // [cfe] The argument type 'String' can't be assigned to the parameter type 'num?'.
+    super == stringQuestion;
+    //       ^^^^^^^^^^^^^^
+    // [analyzer] STATIC_WARNING.ARGUMENT_TYPE_NOT_ASSIGNABLE
+    // [cfe] The argument type 'String?' can't be assigned to the parameter type 'num?'.
+  }
+}