analyzer: mock SDK: correct declarations in core library

* The declared static type of `override` is `Object`.
* All `@Since` annotations specifying versions < 2.12 are removed.
* BigInt is abstract, so `compareTo` can be abstract.
* BigInt.parse is external.
* bool is not abstract, so it's methods need implementations.
* DateTime implements `Comparable<DateTime>`.
* pragma is final.
* Exception is abstract.
* `int.parse` has no `onError` parameter.
* Sink is generic.
* StackTrace is abstract.
* Because String is abstract, it's methods do not need impls.
* String.contains takes a Pattern, not a String.
* Type is abstract.
* UnsupportedError extends Error.
* Uri is abstract.

Change-Id: Iede9b47c621b1ce8cbbad79da4c69b8ada54e8ab
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/450964
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

pkg/analyzer/lib/src/test_utilities/mock_sdk.dart

@@ -261,40 +261,36 @@ import "dart:_internal" as internal show Symbol;
 @Since("2.1")
 export 'dart:async' show Future, Stream;
 
-const deprecated = const Deprecated("next release");
+const Deprecated deprecated = Deprecated("next release");
 
-const override = const _Override();
+const Object override = _Override();
 
 external bool identical(Object? a, Object? b);
 
 void print(Object? object) {}
 
 class ArgumentError extends Error {
-  ArgumentError([message]);
+  ArgumentError([dynamic message, @Since("2.14") String? name]);
 
-  @Since("2.1")
-  static T checkNotNull<@Since("2.8") T>(T? argument, [String? name]) => argument!;
+  static T checkNotNull<T>(T? argument, [String? name]) => argument!;
 }
 
 abstract final class BigInt implements Comparable<BigInt> {
-  int compareTo(BigInt other) => 0;
-  static BigInt parse(String source, {int? radix}) => throw 0;
+  int compareTo(BigInt other);
+  external static BigInt parse(String source, {int? radix});
 }
 
-abstract final class bool extends Object {
+final class bool {
   external const factory bool.fromEnvironment(String name,
       {bool defaultValue = false});
 
   external const factory bool.hasEnvironment(String name);
 
-  @Since("2.1")
-  bool operator &(bool other);
+  bool operator &(bool other) => throw 0;
 
-  @Since("2.1")
-  bool operator |(bool other);
+  bool operator |(bool other) => throw 0;
 
-  @Since("2.1")
-  bool operator ^(bool other);
+  bool operator ^(bool other) => throw 0;
 }
 
 abstract class Comparable<T> {
@@ -304,14 +300,15 @@ abstract class Comparable<T> {
 
 typedef Comparator<T> = int Function(T a, T b);
 
-class DateTime extends Object {
+class DateTime implements Comparable<DateTime> {
   external DateTime._now();
   DateTime.now() : this._now();
+  external int compareTo(DateTime other);
   external bool isBefore(DateTime other);
   external int get millisecondsSinceEpoch;
 }
 
-class Deprecated extends Object {
+class Deprecated {
   final String? message;
   final _DeprecationKind _kind;
   const Deprecated(this.message) : _kind = _DeprecationKind.use;
@@ -329,7 +326,7 @@ enum _DeprecationKind {
   use, implement, extend, subclass, instantiate, mixin, optional;
 }
 
-class pragma {
+final class pragma {
   final String name;
   final Object? options;
   const pragma(this.name, [this.options]);
@@ -404,7 +401,7 @@ class Error {
   external StackTrace? get stackTrace;
 }
 
-class Exception {
+abstract interface class Exception {
   factory Exception([var message]) {
     throw 0;
   }
@@ -437,8 +434,7 @@ abstract final class int extends num {
   String toString();
   int truncate();
 
-  external static int parse(String source,
-      {int? radix, @deprecated int onError(String source)?});
+  external static int parse(String source, {int? radix});
 
   external static int? tryParse(String source, {int? radix});
 }
@@ -541,7 +537,7 @@ abstract class Map<K, V> {
   V? remove(Object? key);
 }
 
-final class Null extends Object {
+final class Null {
   factory Null._uninstantiable() {
     throw 0;
   }
@@ -636,11 +632,11 @@ abstract class Set<E> implements Iterable<E> {
       throw '';
 }
 
-abstract class Sink {
+abstract interface class Sink<T> {
   void close();
 }
 
-class StackTrace {}
+abstract interface class StackTrace {}
 
 abstract final class String implements Comparable<String>, Pattern {
   external factory String.fromCharCodes(Iterable<int> charCodes,
@@ -652,24 +648,24 @@ abstract final class String implements Comparable<String>, Pattern {
       {String defaultValue = ""});
 
   List<int> get codeUnits;
-  bool get isEmpty => false;
-  bool get isNotEmpty => false;
-  int get length => 0;
+  bool get isEmpty;
+  bool get isNotEmpty;
+  int get length;
 
   bool operator ==(Object other);
   String operator [](int index);
   String operator +(String other);
   String operator *(int times);
 
   int codeUnitAt(int index);
-  bool contains(String other, [int startIndex = 0]);
+  bool contains(Pattern other, [int startIndex = 0]);
   int indexOf(Pattern pattern, [int start = 0]);
   int lastIndexOf(Pattern pattern, [int? start]);
   bool startsWith(Pattern pattern, [int index = 0]);
   List<String> split(Pattern pattern);
   String splitMapJoin(Pattern pattern,
       {String Function(Match)? onMatch, String Function(String)? onNonMatch});
-  String substring(int startIndex, [int? endIndex]);
+  String substring(int start, [int? end]);
   String toLowerCase();
   String toUpperCase();
 }
@@ -684,15 +680,15 @@ class Symbol {
   const factory Symbol(String name) = internal.Symbol;
 }
 
-class Type {}
+abstract interface class Type {}
 
 class TypeError extends Error {}
 
-class UnsupportedError {
+class UnsupportedError extends Error {
   UnsupportedError(String message);
 }
 
-class Uri {
+abstract interface class Uri {
   factory Uri({
     String? scheme,
     String? userInfo,

pkg/linter/test/rules/avoid_type_to_string_test.dart

@@ -99,110 +99,110 @@ void foo(String Function() p) {}
     );
   }
 
-  test_typeExtendingType_withToStringOverride() async {
+  test_typeImplementsType_withToStringOverride() async {
     await assertNoDiagnostics(r'''
 mixin M {
   @override
   String toString() => '';
 }
-class Type2 extends Type with M {
+class Type2 with M implements Type {
   String get x => toString();
 }
 ''');
   }
 
-  test_typeThatExtendsType() async {
+  test_typeThatExtendsTypeThatImplementsType() async {
+    await assertDiagnostics(
+      r'''
+var x = Type3().toString();
+class Type2 implements Type {}
+class Type3 extends Type2 {}
+''',
+      [lint(16, 8)],
+    );
+  }
+
+  test_typeThatImplementsType() async {
     await assertDiagnostics(
       r'''
 var x = Type2().toString();
-class Type2 extends Type {}
+class Type2 implements Type {}
 ''',
       [lint(16, 8)],
     );
   }
 
-  test_typeThatExtendsType_explicitThis() async {
+  test_typeThatImplementsType_explicitThis() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {
+class Type2 implements Type {
   late var x = this.toString();
 }
 ''',
-      [lint(47, 8)],
+      [lint(50, 8)],
     );
   }
 
-  test_typeThatExtendsType_implicitThis() async {
+  test_typeThatImplementsType_implicitThis() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {
+class Type2 implements Type {
   late var x = toString();
 }
 ''',
-      [lint(42, 8)],
+      [lint(45, 8)],
     );
   }
 
-  test_typeThatExtendsType_super() async {
+  test_typeThatImplementsType_super() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {
+class Type2 implements Type {
   late var x = super.toString();
 }
 ''',
-      [lint(48, 8)],
+      [lint(51, 8)],
     );
   }
 
-  test_typeThatExtendsType_tearoff() async {
+  test_typeThatImplementsType_tearoff() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {}
+class Type2 implements Type {}
 void f(Type2 t) {
   foo(t.toString);
 }
 void foo(String Function() p) {}
 ''',
-      [lint(54, 8)],
+      [lint(57, 8)],
     );
   }
 
-  test_typeThatExtendsType_tearoff_explicitThis() async {
+  test_typeThatImplementsType_tearoff_explicitThis() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {
+class Type2 implements Type {
   void f() {
     foo(this.toString);
   }
   void foo(String Function() p) {}
 }
 ''',
-      [lint(53, 8)],
+      [lint(56, 8)],
     );
   }
 
-  test_typeThatExtendsType_tearoff_implicitThis() async {
+  test_typeThatImplementsType_tearoff_implicitThis() async {
     await assertDiagnostics(
       r'''
-class Type2 extends Type {
+class Type2 implements Type {
   void f() {
     foo(toString);
   }
   void foo(String Function() p) {}
 }
 ''',
-      [lint(48, 8)],
-    );
-  }
-
-  test_typeThatExtendsTypeThatExtendsType() async {
-    await assertDiagnostics(
-      r'''
-var x = Type3().toString();
-class Type2 extends Type {}
-class Type3 extends Type2 {}
-''',
-      [lint(16, 8)],
+      [lint(51, 8)],
     );
   }
 }