- Change "static final" to "static const" in the

pkg/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();
+const Matcher isEmpty = const _Empty();
 
 class _Empty extends BaseMatcher {
   const _Empty();
   bool matches(item, MatchState matchState) {
     if (item is Map || item is Collection) {
       return item.isEmpty();
     } else if (item is String) {
       return item.length == 0;
     } else {
       return false;
     }
   }
   Description describe(Description description) =>
       description.add('empty');
 }
 
 /** A matcher that matches any null value. */
-final Matcher isNull = const _IsNull();
+const Matcher isNull = const _IsNull();
 
 /** A matcher that matches any non-null value. */
-final Matcher isNotNull = const _IsNotNull();
+const Matcher isNotNull = const _IsNotNull();
 
 class _IsNull extends BaseMatcher {
   const _IsNull();
   bool matches(item, MatchState matchState) => item == null;
   Description describe(Description description) =>
       description.add('null');
 }
 
 class _IsNotNull extends BaseMatcher {
   const _IsNotNull();
   bool matches(item, MatchState matchState) => item != null;
   Description describe(Description description) =>
       description.add('not null');
 }
 
 /** A matcher that matches the Boolean value true. */
-final Matcher isTrue = const _IsTrue();
+const Matcher isTrue = const _IsTrue();
 
 /** A matcher that matches anything except the Boolean value true. */
-final Matcher isFalse = const _IsFalse();
+const Matcher isFalse = const _IsFalse();
 
 class _IsTrue extends BaseMatcher {
   const _IsTrue();
   bool matches(item, MatchState matchState) => item == true;
   Description describe(Description description) =>
       description.add('true');
 }
 
 class _IsFalse extends BaseMatcher {
   const _IsFalse();
@@ skipping 122 matching lines @@
 
   Description describe(Description description) =>
     description.addDescriptionOf(_expected);
 
   Description describeMismatch(item, Description mismatchDescription,
                                MatchState matchState, bool verbose) =>
     mismatchDescription.add(_match(_expected, item));
 }
 
 /** A matcher that matches any value. */
-final Matcher anything = const _IsAnything();
+const Matcher anything = const _IsAnything();
 
 class _IsAnything extends BaseMatcher {
   const _IsAnything();
   bool matches(item, MatchState matchState) => true;
   Description describe(Description description) =>
       description.add('anything');
 }
 
 /**
  * Returns a matcher that matches if an object is an instance
@@ skipping 27 matching lines @@
  *   * A [Function] that throws an exception when called. The function cannot
  *     take any arguments. If you want to test that a function expecting
  *     arguments throws, wrap it in another zero-argument function that calls
  *     the one you want to test.
  *
  *   * A [Future] that completes with an exception. Note that this creates an
  *     asynchronous expectation. The call to `expect()` that includes this will
  *     return immediately and execution will continue. Later, when the future
  *     completes, the actual expectation will run.
  */
-final Matcher throws = const _Throws();
+const Matcher throws = const _Throws();
 
 /**
  * This can be used to match two kinds of objects:
  *
  *   * A [Function] that throws an exception when called. The function cannot
  *     take any arguments. If you want to test that a function expecting
  *     arguments throws, wrap it in another zero-argument function that calls
  *     the one you want to test.
  *
  *   * A [Future] that completes with an exception. Note that this creates an
  *     asynchronous expectation. The call to `expect()` that includes this will
  *     return immediately and execution will continue. Later, when the future
  *     completes, the actual expectation will run.
  *
  * In both cases, when an exception is thrown, this will test that the exception
  * object matches [matcher]. If [matcher] is not an instance of [Matcher], it
  * will implicitly be treated as `equals(matcher)`.
  */
 Matcher throwsA(matcher) => new _Throws(wrapMatcher(matcher));
 
 /**
  * A matcher that matches a function call against no exception.
  * 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();
+const Matcher returnsNormally = const _ReturnsNormally();
 
 class _Throws extends BaseMatcher {
   final Matcher _matcher;
 
   const _Throws([Matcher matcher]) :
     this._matcher = matcher;
 
   bool matches(item, MatchState matchState) {
     if (item is Future) {
       // Queue up an asynchronous expectation that validates when the future
@@ skipping 114 matching lines @@
  */
 
 /* abstract */ class _ExceptionMatcher extends BaseMatcher {
   final String _name;
   const _ExceptionMatcher(this._name);
   Description describe(Description description) =>
       description.add(_name);
 }
 
 /** A matcher for FormatExceptions. */
-final isFormatException = const _FormatException();
+const isFormatException = const _FormatException();
 
 /** A matcher for functions that throw FormatException */
-final Matcher throwsFormatException =
+const Matcher throwsFormatException =
     const _Throws(isFormatException);
 
 class _FormatException extends _ExceptionMatcher {
   const _FormatException() : super("FormatException");
   bool matches(item, MatchState matchState) => item is FormatException;
 }
 
 /** A matcher for Exceptions. */
-final isException = const _Exception();
+const isException = const _Exception();
 
 /** A matcher for functions that throw Exception */
-final Matcher throwsException = const _Throws(isException);
+const Matcher throwsException = const _Throws(isException);
 
 class _Exception extends _ExceptionMatcher {
   const _Exception() : super("Exception");
   bool matches(item, MatchState matchState) => item is Exception;
 }
 
 /** A matcher for IllegalArgumentExceptions. */
-final isIllegalArgumentException = const _IllegalArgumentException();
+const isIllegalArgumentException = const _IllegalArgumentException();
 
 /** A matcher for functions that throw IllegalArgumentException */
-final Matcher throwsIllegalArgumentException =
+const Matcher throwsIllegalArgumentException =
     const _Throws(isIllegalArgumentException);
 
 class _IllegalArgumentException extends _ExceptionMatcher {
   const _IllegalArgumentException() : super("IllegalArgumentException");
   bool matches(item, MatchState matchState) => item is IllegalArgumentException;
 }
 
 /** A matcher for IllegalJSRegExpExceptions. */
-final isIllegalJSRegExpException = const _IllegalJSRegExpException();
+const isIllegalJSRegExpException = const _IllegalJSRegExpException();
 
 /** A matcher for functions that throw IllegalJSRegExpException */
-final Matcher throwsIllegalJSRegExpException =
+const Matcher throwsIllegalJSRegExpException =
     const _Throws(isIllegalJSRegExpException);
 
 class _IllegalJSRegExpException extends _ExceptionMatcher {
   const _IllegalJSRegExpException() : super("IllegalJSRegExpException");
   bool matches(item, MatchState matchState) => item is IllegalJSRegExpException;
 }
 
 /** A matcher for IndexOutOfRangeExceptions. */
-final isIndexOutOfRangeException = const _IndexOutOfRangeException();
+const isIndexOutOfRangeException = const _IndexOutOfRangeException();
 
 /** A matcher for functions that throw IndexOutOfRangeException */
-final Matcher throwsIndexOutOfRangeException =
+const Matcher throwsIndexOutOfRangeException =
     const _Throws(isIndexOutOfRangeException);
 
 class _IndexOutOfRangeException extends _ExceptionMatcher {
   const _IndexOutOfRangeException() : super("IndexOutOfRangeException");
   bool matches(item, MatchState matchState) => item is IndexOutOfRangeException;
 }
 
 /** A matcher for NoSuchMethodExceptions. */
-final isNoSuchMethodException = const _NoSuchMethodException();
+const isNoSuchMethodException = const _NoSuchMethodException();
 
 /** A matcher for functions that throw NoSuchMethodException */
-final Matcher throwsNoSuchMethodException =
+const Matcher throwsNoSuchMethodException =
     const _Throws(isNoSuchMethodException);
 
 class _NoSuchMethodException extends _ExceptionMatcher {
   const _NoSuchMethodException() : super("NoSuchMethodException");
   bool matches(item, MatchState matchState) => item is NoSuchMethodException;
 }
 
 /** A matcher for NotImplementedExceptions. */
-final isNotImplementedException = const _NotImplementedException();
+const isNotImplementedException = const _NotImplementedException();
 
 /** A matcher for functions that throw Exception */
-final Matcher throwsNotImplementedException =
+const Matcher throwsNotImplementedException =
     const _Throws(isNotImplementedException);
 
 class _NotImplementedException extends _ExceptionMatcher {
   const _NotImplementedException() : super("NotImplementedException");
   bool matches(item, MatchState matchState) => item is NotImplementedException;
 }
 
 /** A matcher for NullPointerExceptions. */
-final isNullPointerException = const _NullPointerException();
+const isNullPointerException = const _NullPointerException();
 
 /** A matcher for functions that throw NotNullPointerException */
-final Matcher throwsNullPointerException =
+const Matcher throwsNullPointerException =
     const _Throws(isNullPointerException);
 
 class _NullPointerException extends _ExceptionMatcher {
   const _NullPointerException() : super("NullPointerException");
   bool matches(item, MatchState matchState) => item is NullPointerException;
 }
 
 /** A matcher for UnsupportedOperationExceptions. */
-final isUnsupportedOperationException = const _UnsupportedOperationException();
+const isUnsupportedOperationException = const _UnsupportedOperationException();
 
 /** A matcher for functions that throw UnsupportedOperationException */
-final Matcher throwsUnsupportedOperationException =
+const Matcher throwsUnsupportedOperationException =
     const _Throws(isUnsupportedOperationException);
 
 class _UnsupportedOperationException extends _ExceptionMatcher {
   const _UnsupportedOperationException() :
       super("UnsupportedOperationException");
   bool matches(item, MatchState matchState) => item is UnsupportedOperationException;
 }
 
 /**
  * Returns a matcher that matches if an object has a length property
@@ skipping 104 matching lines @@
   final _matcher;
   final String _description;
 
   const _Predicate(this._matcher, this._description);
 
   bool matches(item, MatchState matchState) => _matcher(item);
 
   Description describe(Description description) =>
       description.add(_description);
 }