anchor.diff:    void _validateTopLevelInitializer(String name, Expression n) {
       n.accept(new _TopLevelInitializerValidator(this, name));
     }
  +
  +  @override
  +  void _visitForEachParts(ForEachParts node, SimpleIdentifier loopVariable) {
  +    // Safely handle malformed statements.
  +    if (loopVariable == null) {
  +      return;
  +    }
  +    Token awaitKeyword;
  +    AstNode parent = node.parent;
  +    if (parent is ForStatement2) {
  +      awaitKeyword = parent.awaitKeyword;
  +    } else if (parent is ForElement) {
  +      awaitKeyword = parent.awaitKeyword;
  +    } else {
  +      throw new StateError(
  +          'Unexpected parent of ForEachParts: ${parent.runtimeType}');
  +    }
  +    // Find the element type of the sequence.
  +    var sequenceInterface = awaitKeyword != null
  +        ? typeProvider.streamType
  +        : typeProvider.iterableType;
  +    var iterableType = _getExpressionType(node.iterable);
  +    var elementType =
  +        rules.mostSpecificTypeArgument(iterableType, sequenceInterface);
  +
  +    // If the sequence is not an Iterable (or Stream for await for) but is a
  +    // supertype of it, do an implicit downcast to Iterable<dynamic>. Then
  +    // we'll do a separate cast of the dynamic element to the variable's type.
  +    if (elementType == null) {
  +      var sequenceType =
  +          sequenceInterface.instantiate([DynamicTypeImpl.instance]);
  +
  +      if (rules.isSubtypeOf(sequenceType, iterableType)) {
  +        _recordImplicitCast(node.iterable, sequenceType, from: iterableType);
  +        elementType = DynamicTypeImpl.instance;
  +      }
  +    }
  +    // If the sequence doesn't implement the interface at all, [ErrorVerifier]
  +    // will report the error, so ignore it here.
  +    if (elementType != null) {
  +      // Insert a cast from the sequence's element type to the loop variable's
  +      // if needed.
  +      _checkImplicitCast(loopVariable, _getExpressionType(loopVariable),
  +          from: elementType);
  +    }
  +  }
   }
   
   /// Checks for overriding declarations of fields and methods. This is used to
  
positive.code:   }
  
    @override
    void visitMapLiteral(MapLiteral node) {
      DartType ktype = DynamicTypeImpl.instance;
      DartType vtype = DynamicTypeImpl.instance;
  
negative.code:       checkArgument(entry.value, vtype);
      }
      super.visitMapLiteral(node);
    }
  
    @override
    void visitMapLiteral2(MapLiteral2 node) {
      DartType keyType = DynamicTypeImpl.instance;
      DartType valueType = DynamicTypeImpl.instance;
      if (node.typeArguments != null) {
        NodeList<TypeAnnotation> typeArguments = node.typeArguments.arguments;
        if (typeArguments.length > 0) {
          keyType = typeArguments[0].type;
        }
        if (typeArguments.length > 1) {
          valueType = typeArguments[1].type;
        }
      } else {
        DartType staticType = node.staticType;
        if (staticType is InterfaceType) {
          List<DartType> typeArguments = staticType.typeArguments;
          if (typeArguments != null) {
            if (typeArguments.length > 0) {
              keyType = typeArguments[0];
            }
            if (typeArguments.length > 1) {
              valueType = typeArguments[1];
            }
          }
        }
      }
      NodeList<MapElement> entries = node.entries;
      for (int i = 0; i < entries.length; i++) {
        checkMapElement(entries[i], keyType, valueType);
      }
      super.visitMapLiteral2(node);
    }
  
    @override
  