Fix an error and a warning in unittest.

pkg/unittest/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.
 
 part of matcher;
 
 /**
  * Returns a matcher that matches empty strings, maps or iterables
  * (including collections).
  */
@@ skipping 69 matching lines @@
       description.add('same instance as ').addDescriptionOf(_expected);
 }
 
 /**
  * Returns a matcher that does a deep recursive match. This only works
  * with scalars, Maps and Iterables. To handle cyclic structures a
  * recursion depth [limit] can be provided. The default limit is 100.
  */
 Matcher equals(expected, [limit=100]) =>
     expected is String
-        ? new _StringEqualsMatcher(expected) 
+        ? new _StringEqualsMatcher(expected)
         : new _DeepMatcher(expected, limit);
 
 class _DeepMatcher extends BaseMatcher {
   final _expected;
   final int _limit;
   var count;
 
   _DeepMatcher(this._expected, [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;
     var index = 0;
     while (true) {
+      var newLocation = '${location}[${index}]';
       if (expectedIterator.moveNext()) {
-        var newLocation = '${location}[${index}]';
         if (actualIterator.moveNext()) {
           var rp = matcher(expectedIterator.current,
                            actualIterator.current, newLocation,
                            depth);
           if (rp != null) return rp;
           ++index;
         } else {
           return ['shorter than expected', newLocation];
         }
       } else if (actualIterator.moveNext()) {
@@ skipping 92 matching lines @@
 
   bool matches(item, Map matchState) =>
       _match(_expected, item, matchState) == null;
 
   Description describe(Description description) =>
     description.addDescriptionOf(_expected);
 
   Description describeMismatch(item, Description mismatchDescription,
                                Map matchState, bool verbose) {
     var reason = matchState['reason'];
-    // If we didn't get a good reason, that would normally be a 
+    // If we didn't get a good reason, that would normally be a
     // simple 'is <value>' message. We only add that if the mismatch
     // description is non empty (so we are supplementing the mismatch
     // description).
     if (reason.length == 0 && mismatchDescription.length > 0) {
       mismatchDescription.add('is ').addDescriptionOf(item);
     } else {
       mismatchDescription.add(reason);
     }
     return mismatchDescription;
   }
@@ skipping 584 matching lines @@
     var innerDescription = new StringDescription();
     _matcher.describeMismatch(matchState['feature'], innerDescription,
         matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }