Better casting of for-in loops.

pkg/analyzer/lib/src/task/strong/info.dart

 // Copyright (c) 2015, 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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.info;
 
@@ skipping 49 matching lines @@
   }
 }
 
 /// Base class for all casts from base type to sub type.
 abstract class DownCast extends CoercionInfo {
   final DartType _fromType;
   final DartType _toType;
 
   DownCast._internal(
       TypeSystem rules, Expression expression, this._fromType, this._toType)
-      : super(rules, expression) {
-    assert(_toType != baseType &&
-        _fromType == baseType &&
-        (baseType.isDynamic ||
-            // Call methods make the following non-redundant.
-            _toType.isSubtypeOf(baseType) ||
-            baseType.isAssignableTo(_toType)));
-  }
+      : super(rules, expression);
 
   @override
   List<Object> get arguments => [baseType, convertedType];
 
+  /// The type being cast from.
+  ///
+  /// This is usually the static type of the associated expression, but may not
+  /// be if the cast is attached to a variable in a for-in loop.
+  @override
+  DartType get baseType => _fromType;
+
   DartType get convertedType => _toType;
 
   @override
   String get message => 'Unsound implicit cast from {0} to {1}';
 
-  // Factory to create correct DownCast variant.
+  /// Factory to create correct DownCast variant.
   static StaticInfo create(StrongTypeSystemImpl rules, Expression expression,
       DartType fromType, DartType toType) {
     // toT <:_R fromT => to <: fromT
     // NB: classes with call methods are subtypes of function
     // types, but the function type is not assignable to the class
     assert(toType.isSubtypeOf(fromType) || fromType.isAssignableTo(toType));
 
     // Handle null call specially.
     if (expression is NullLiteral) {
       // TODO(vsm): Create a NullCast for this once we revisit nonnullability.
@@ skipping 441 matching lines @@
         super(expression);
 
   @override
   List<Object> get arguments => [node, baseType, expectedType];
   @override
   String get message => 'Type check failed: {0} ({1}) is not of type {2}';
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }