feature: Add a type argument to TypeMatcher and make it non-abstract

Eliminates 13 implementations
Deprecate the existing `name` parameter - tell folks to use the type arg

Deprecate isInstanceOf class. Tell folks to use TypeMatcher<T> instead
Removed isInstanceOf tests from core_matchers_test
  centralizing tests in type_matcher_test

Author: kevmoo

CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.12.3
+
+- Added a type parameter to `TypeMatcher` and make it non-abstract.
+  - Can now be used directly as `const TypeMatcher<MyType>()`.
+  - Deprecated the `name` constructor argument. It's redundant to the type
+    parameter.
+
+- Deprecated the `isInstanceOf` class. Use `TypeMatcher` instead.
+
 ## 0.12.2+1
 
 - Updated SDK version to 2.0.0-dev.17.0

lib/src/core_matchers.dart

@@ -113,14 +113,10 @@ class _IsAnything extends Matcher {
 /// 'Foo', we would write:
 ///
 ///     expect(bar, new isInstanceOf<Foo>());
+@Deprecated('Use `const TypeMatcher<MyType>()` instead.')
 // ignore: camel_case_types
-class isInstanceOf<T> extends Matcher {
+class isInstanceOf<T> extends TypeMatcher<T> {
   const isInstanceOf();
-
-  bool matches(item, Map matchState) => item is T;
-
-  Description describe(Description description) =>
-      description.add('an instance of $T');
 }
 
 /// A matcher that matches a function call against no exception.
@@ -178,27 +174,32 @@ class _ReturnsNormally extends Matcher {
  * for each exception type.
  */
 
-abstract class TypeMatcher extends Matcher {
+class TypeMatcher<T> extends Matcher {
   final String _name;
-  const TypeMatcher(this._name);
-  Description describe(Description description) => description.add(_name);
+  const TypeMatcher(
+      [@Deprecated('Provide a type argument to TypeMatcher and omit the name. '
+          'This argument will be removed in the next release.')
+          String name])
+      : this._name =
+            // ignore: deprecated_member_use
+            name;
+
+  Description describe(Description description) {
+    if (_name == null) {
+      return description.addDescriptionOf(T);
+    } else {
+      return description.add('instance of `$_name`');
+    }
+  }
+
+  bool matches(item, Map matchState) => item is T;
 }
 
 /// A matcher for Map types.
-const Matcher isMap = const _IsMap();
-
-class _IsMap extends TypeMatcher {
-  const _IsMap() : super("Map");
-  bool matches(item, Map matchState) => item is Map;
-}
+const Matcher isMap = const TypeMatcher<Map>();
 
 /// A matcher for List types.
-const Matcher isList = const _IsList();
-
-class _IsList extends TypeMatcher {
-  const _IsList() : super('List');
-  bool matches(item, Map matchState) => item is List;
-}
+const Matcher isList = const TypeMatcher<List>();
 
 /// Returns a matcher that matches if an object has a length property
 /// that matches [matcher].

lib/src/error_matchers.dart

@@ -6,90 +6,36 @@ import 'core_matchers.dart';
 import 'interfaces.dart';
 
 /// A matcher for ArgumentErrors.
-const Matcher isArgumentError = const _ArgumentError();
-
-class _ArgumentError extends TypeMatcher {
-  const _ArgumentError() : super("ArgumentError");
-  bool matches(item, Map matchState) => item is ArgumentError;
-}
+const Matcher isArgumentError = const TypeMatcher<ArgumentError>();
 
 /// A matcher for ConcurrentModificationError.
 const Matcher isConcurrentModificationError =
-    const _ConcurrentModificationError();
-
-class _ConcurrentModificationError extends TypeMatcher {
-  const _ConcurrentModificationError() : super("ConcurrentModificationError");
-  bool matches(item, Map matchState) => item is ConcurrentModificationError;
-}
+    const TypeMatcher<ConcurrentModificationError>();
 
 /// A matcher for CyclicInitializationError.
-const Matcher isCyclicInitializationError = const _CyclicInitializationError();
-
-class _CyclicInitializationError extends TypeMatcher {
-  const _CyclicInitializationError() : super("CyclicInitializationError");
-  bool matches(item, Map matchState) => item is CyclicInitializationError;
-}
+const Matcher isCyclicInitializationError =
+    const TypeMatcher<CyclicInitializationError>();
 
 /// A matcher for Exceptions.
-const Matcher isException = const _Exception();
-
-class _Exception extends TypeMatcher {
-  const _Exception() : super("Exception");
-  bool matches(item, Map matchState) => item is Exception;
-}
+const Matcher isException = const TypeMatcher<Exception>();
 
 /// A matcher for FormatExceptions.
-const Matcher isFormatException = const _FormatException();
-
-class _FormatException extends TypeMatcher {
-  const _FormatException() : super("FormatException");
-  bool matches(item, Map matchState) => item is FormatException;
-}
+const Matcher isFormatException = const TypeMatcher<FormatException>();
 
 /// A matcher for NoSuchMethodErrors.
-const Matcher isNoSuchMethodError = const _NoSuchMethodError();
-
-class _NoSuchMethodError extends TypeMatcher {
-  const _NoSuchMethodError() : super("NoSuchMethodError");
-  bool matches(item, Map matchState) => item is NoSuchMethodError;
-}
+const Matcher isNoSuchMethodError = const TypeMatcher<NoSuchMethodError>();
 
 /// A matcher for NullThrownError.
-const Matcher isNullThrownError = const _NullThrownError();
-
-class _NullThrownError extends TypeMatcher {
-  const _NullThrownError() : super("NullThrownError");
-  bool matches(item, Map matchState) => item is NullThrownError;
-}
+const Matcher isNullThrownError = const TypeMatcher<NullThrownError>();
 
 /// A matcher for RangeErrors.
-const Matcher isRangeError = const _RangeError();
-
-class _RangeError extends TypeMatcher {
-  const _RangeError() : super("RangeError");
-  bool matches(item, Map matchState) => item is RangeError;
-}
+const Matcher isRangeError = const TypeMatcher<RangeError>();
 
 /// A matcher for StateErrors.
-const Matcher isStateError = const _StateError();
-
-class _StateError extends TypeMatcher {
-  const _StateError() : super("StateError");
-  bool matches(item, Map matchState) => item is StateError;
-}
+const Matcher isStateError = const TypeMatcher<StateError>();
 
 /// A matcher for UnimplementedErrors.
-const Matcher isUnimplementedError = const _UnimplementedError();
-
-class _UnimplementedError extends TypeMatcher {
-  const _UnimplementedError() : super("UnimplementedError");
-  bool matches(item, Map matchState) => item is UnimplementedError;
-}
+const Matcher isUnimplementedError = const TypeMatcher<UnimplementedError>();
 
 /// A matcher for UnsupportedError.
-const Matcher isUnsupportedError = const _UnsupportedError();
-
-class _UnsupportedError extends TypeMatcher {
-  const _UnsupportedError() : super("UnsupportedError");
-  bool matches(item, Map matchState) => item is UnsupportedError;
-}
+const Matcher isUnsupportedError = const TypeMatcher<UnsupportedError>();

test/core_matchers_test.dart

@@ -228,12 +228,6 @@ void main() {
     shouldFail(actual3, equals(expected3), reason3);
   });
 
-  test('isInstanceOf', () {
-    shouldFail(0, const isInstanceOf<String>(),
-        "Expected: an instance of String Actual: <0>");
-    shouldPass('cow', const isInstanceOf<String>());
-  });
-
   group('Predicate Matchers', () {
     test('isInstanceOf', () {
       shouldFail(0, predicate((x) => x is String, "an instance of String"),

test/type_matcher_test.dart

@@ -26,8 +26,10 @@ void main() {
   _test('NullThrownError', isNullThrownError, new NullThrownError());
 
   group('custom `TypeMatcher`', () {
+    // ignore: deprecated_member_use
     _test('String', const isInstanceOf<String>(), 'hello');
     _test('String', const _StringMatcher(), 'hello');
+    _test('String', const TypeMatcher<String>(), 'hello');
   });
 }
 
@@ -41,21 +43,17 @@ void _test(String name, Matcher typeMatcher, Object matchingType) {
     }
 
     test('fails', () {
-      shouldFail(
-          const _TestType(),
-          typeMatcher,
-          anyOf(
-              // Handles the TypeMatcher case
-              equalsIgnoringWhitespace('Expected: $name Actual: ?:<TestType>'),
-              // Handles the `isInstanceOf` case
-              equalsIgnoringWhitespace(
-                  'Expected: an instance of $name Actual: ?:<TestType>')));
+      shouldFail(const _TestType(), typeMatcher,
+          'Expected: instance of `$name` Actual: ?:<TestType>');
     });
   });
 }
 
+// Validate that existing implementations continue to work.
 class _StringMatcher extends TypeMatcher {
-  const _StringMatcher() : super('String');
+  const _StringMatcher() : super(
+            // ignore: deprecated_member_use
+            'String');
 
   bool matches(item, Map matchState) => item is String;
 }