Removes constructor initializer in named parameter of private member

lib/unittest/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.
 
 
 /**
  * Returns a matcher that matches empty strings, maps or collections.
  */
 final Matcher isEmpty = const _Empty();
 
@@ skipping 100 matching lines @@
  *
  *     expect(bar, new isInstanceOf<Foo>());
  *
  * To get better error message, supply a name when creating the
  * Type wrapper; e.g.:
  *
  *     expect(bar, new isInstanceOf<Foo>('Foo'));
  */
 class isInstanceOf<T> extends BaseMatcher {
   final String _name;
-  const isInstanceOf([this._name = 'specified type']);
+  const isInstanceOf([name = 'specified type']) : this._name = name;
   bool matches(obj) => obj is T;
   // The description here is lame :-(
   Description describe(Description description) =>
       description.add('an instance of ${_name}');
 }
 
 /**
  * A matcher that matches functions that throw exceptions when called.
  * The value passed to expect() should be a reference to the function.
  * Note that the function cannot take arguments; to handle this
@@ skipping 19 matching lines @@
  * The function will be called once. Any exceptions will be silently swallowed.
  * The value passed to expect() should be a reference to the function.
  * Note that the function cannot take arguments; to handle this
  * a wrapper will have to be created.
  */
 final Matcher returnsNormally = const _ReturnsNormally();
 
 class _Throws extends BaseMatcher {
   final Matcher _matcher;
 
-  const _Throws([Matcher this._matcher = null]);
+  const _Throws([Matcher matcher = null]) : this._matcher = matcher;
 
   bool matches(item) {
     try {
       item();
       return false;
     } catch (final e) {
       return _matcher == null || _matcher.matches(e);
     }
   }
 
@@ skipping 76 matching lines @@
 
 /**
  * Returns a matcher that matches if an object has a length property
  * that matches [matcher].
  */
 Matcher hasLength(matcher) =>
     new _HasLength(wrapMatcher(matcher));
 
 class _HasLength extends BaseMatcher {
   final Matcher _matcher;
-  const _HasLength([Matcher this._matcher = null]);
+  const _HasLength([Matcher matcher = null]) : this._matcher = matcher;
 
   bool matches(item) {
     return _matcher.matches(item.length);
   }
 
   Description describe(Description description) =>
     description.add('an object with length of ').
         addDescriptionOf(_matcher);
 
   Description describeMismatch(item, Description mismatchDescription) {
@@ skipping 49 matching lines @@
     }
   }
   return reason;
 }
 
 class _DeepMatcher extends BaseMatcher {
   final _expected;
   final int _limit;
   var count;
 
-  _DeepMatcher(this._expected, [this._limit = 1000]);
+  _DeepMatcher(this._expected, [limit = 1000]) : this._limit = limit;
 
   String _recursiveMatch(expected, actual, String location) {
     String reason = null;
     if (++count >= _limit) {
       reason =  'item comparison limit exceeded';
     } else if (expected is Iterable) {
       reason = _compareIterables(expected, actual, _recursiveMatch);
     } else if (expected is Map) {
       if (actual is !Map) {
         reason = 'expected a map';
@@ skipping 62 matching lines @@
       }
     } else if (item is Map) {
       return item.containsKey(_expected);
     }
     return false;
   }
 
   Description describe(Description description) =>
       description.add('contains ').addDescriptionOf(_expected);
 }