pkg/matcher: small nits from previous CL

pkg/matcher/lib/src/core_matchers.dart

 // Copyright (c) 2012, 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 matcher.core_matchers;
 
 import 'dart:async';
 
 import 'description.dart';
 import 'expect.dart';
@@ skipping 78 matching lines @@
 Matcher equals(expected, [int limit=100]) =>
     expected is String
         ? new _StringEqualsMatcher(expected)
         : new _DeepMatcher(expected, limit);
 
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
-  _DeepMatcher(this._expected, [limit = 1000]) : this._limit = limit;
+  _DeepMatcher(this._expected, [int limit = 1000]) : this._limit = limit;
 
   // Returns a pair (reason, location)
   List _compareIterables(expected, actual, matcher, depth, location) {
     if (actual is! Iterable) return ['is not Iterable', location];
 
     var expectedIterator = expected.iterator;
     var actualIterator = actual.iterator;
     for (var index = 0; ; index++) {
       // Advance in lockstep.
       var expectedNext = expectedIterator.moveNext();
@@ skipping 396 matching lines @@
  * For now the only solution for all platforms seems to be separate classes
  * for each exception type.
  */
 
 abstract class TypeMatcher extends Matcher {
   final String _name;
   const TypeMatcher(this._name);
   Description describe(Description description) => description.add(_name);
 }
 
-
-
 /// A matcher for Map types.
-const isMap = const _IsMap();
+const Matcher isMap = const _IsMap();
 
 class _IsMap extends TypeMatcher {
   const _IsMap() : super("Map");
   bool matches(item, Map matchState) => item is Map;
 }
 
 /// A matcher for List types.
-const isList = const _IsList();
+const Matcher isList = const _IsList();
 
 class _IsList extends TypeMatcher {
   const _IsList() : super("List");
   bool matches(item, Map matchState) => item is List;
 }
 
 /// Returns a matcher that matches if an object has a length property
 /// that matches [matcher].
 Matcher hasLength(matcher) => new _HasLength(wrapMatcher(matcher));
 
@@ skipping 70 matching lines @@
       return mismatchDescription.add('is not a string, map or iterable');
     }
   }
 }
 
 /// Returns a matcher that matches if the match argument is in
 /// the expected value. This is the converse of [contains].
 Matcher isIn(expected) => new _In(expected);
 
 class _In extends Matcher {
-
   final _expected;
 
   const _In(this._expected);
 
   bool matches(item, Map matchState) {
     if (_expected is String) {
       return _expected.indexOf(item) >= 0;
     } else if (_expected is Iterable) {
       return _expected.any((e) => e == item);
     } else if (_expected is Map) {
@@ skipping 73 matching lines @@
         addDescriptionOf(matchState['feature']);
     var innerDescription = new StringDescription();
     _matcher.describeMismatch(matchState['feature'], innerDescription,
         matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }