anchor.diff:        }
       }
   
  +    node.visitChildren(this);
  +  }
  +
  +  @override
  +  void visitForPartsWithDeclarations(ForPartsWithDeclarations node) {
  +    if (node.condition != null) {
  +      checkBoolean(node.condition);
  +    }
  +    node.visitChildren(this);
  +  }
  +
  +  @override
  +  void visitForPartsWithExpression(ForPartsWithExpression node) {
  +    if (node.condition != null) {
  +      checkBoolean(node.condition);
  +    }
       node.visitChildren(this);
     }
   
  
positive.code:   void checkBoolean(Expression expr) =>
        checkAssignment(expr, typeProvider.boolType);
  
    void checkForCast(Expression expr, DartType type) {
      if (expr is ParenthesizedExpression) {
        checkForCast(expr.expression, type);
      } else {
        _checkImplicitCast(expr, type);
      }
    }
  
  
negative.code:   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
  