Fixes #287 and other failures statically checking SDK tests

lib/src/checker/checker.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.
 
 library dev_compiler.src.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 65 matching lines @@
   ///     }
   ///     class Parent extends Grandparent {
   ///         m(A a) {}
   ///     }
   ///     class Test extends Parent {
   ///         m(B a) {} // invalid override
   ///     }
   void _checkSuperOverrides(ClassDeclaration node) {
     var seen = new Set<String>();
     var current = node.element.type;
+    var visited = new Set<InterfaceType>();
     do {
+      visited.add(current);
       current.mixins.reversed
           .forEach((m) => _checkIndividualOverridesFromClass(node, m, seen));
       _checkIndividualOverridesFromClass(node, current.superclass, seen);
       current = current.superclass;
-    } while (!current.isObject);
+    } while (!current.isObject && !visited.contains(current));
   }
 
   /// Checks that implementations correctly override all reachable interfaces.
   /// In particular, we need to check these overrides for the definitions in
   /// the class itself and each its superclasses. If a superclass is not
   /// abstract, then we can skip its transitive interfaces. For example, in:
   ///
   ///     B extends C implements G
   ///     A extends B with E, F implements H, I
   ///
@@ skipping 43 matching lines @@
   /// Checks that [cls] and its super classes (including mixins) correctly
   /// overrides each interface in [interfaces]. If [includeParents] is false,
   /// then mixins are still checked, but the base type and it's transitive
   /// supertypes are not.
   ///
   /// [cls] can be either a [ClassDeclaration] or a [InterfaceType]. For
   /// [ClassDeclaration]s errors are reported on the member that contains the
   /// invalid override, for [InterfaceType]s we use [errorLocation] instead.
   void _checkInterfacesOverrides(
       cls, Iterable<InterfaceType> interfaces, Set<String> seen,
-      {bool includeParents: true, AstNode errorLocation}) {
+      {Set<InterfaceType> visited,
+      bool includeParents: true,
+      AstNode errorLocation}) {
     var node = cls is ClassDeclaration ? cls : null;
     var type = cls is InterfaceType ? cls : node.element.type;
 
+    if (visited == null) {
+      visited = new Set<InterfaceType>();
+    } else if (visited.contains(type)) {
+      // Malformed type.
+      return;
+    } else {
+      visited.add(type);
+    }
+
     // Check direct overrides on [type]
     for (var interfaceType in interfaces) {
       if (node != null) {
         _checkIndividualOverridesFromClass(node, interfaceType, seen);
       } else {
         _checkIndividualOverridesFromType(
             type, interfaceType, errorLocation, seen);
       }
     }
 
@@ skipping 10 matching lines @@
     }
 
     // Check overrides from its superclasses
     if (includeParents) {
       var parent = type.superclass;
       if (parent.isObject) return;
       var loc = errorLocation != null ? errorLocation : node.extendsClause;
       // No need to copy [seen] here because we made copies above when reporting
       // errors on mixins.
       _checkInterfacesOverrides(parent, interfaces, seen,
-          includeParents: true, errorLocation: loc);
+          visited: visited, includeParents: true, errorLocation: loc);
     }
   }
 
   /// Check that individual methods and fields in [subType] correctly override
   /// the declarations in [baseType].
   ///
   /// The [errorLocation] node indicates where errors are reported, see
   /// [_checkSingleOverride] for more details.
   ///
   /// The set [seen] is used to avoid reporting overrides more than once. It
@@ skipping 25 matching lines @@
       if (member is FieldDeclaration) {
         if (member.isStatic) continue;
         for (var variable in member.fields.variables) {
           var element = variable.element as PropertyInducingElement;
           var name = element.name;
           if (seen.contains(name)) continue;
           var getter = element.getter;
           var setter = element.setter;
           bool found = _checkSingleOverride(getter, baseType, variable, member);
           if (!variable.isFinal &&
+              !variable.isConst &&
               _checkSingleOverride(setter, baseType, variable, member)) {
             found = true;
           }
           if (found) seen.add(name);
         }
       } else {
         if ((member as MethodDeclaration).isStatic) continue;
         var method = (member as MethodDeclaration).element;
         if (seen.contains(method.name)) continue;
         if (_checkSingleOverride(method, baseType, member, member)) {
@@ skipping 137 matching lines @@
 
   @override
   void visitForEachStatement(ForEachStatement node) {
     // Check that the expression is an Iterable.
     var expr = node.iterable;
     var iterableType = node.awaitKeyword != null
         ? rules.provider.streamType
         : rules.provider.iterableType;
     var loopVariable = node.identifier != null
         ? node.identifier
-        : node.loopVariable.identifier;
-    var iteratorType = loopVariable.staticType;
-    var checkedType = iterableType.substitute4([iteratorType]);
-    checkAssignment(expr, checkedType);
+        : node.loopVariable?.identifier;
+    if (loopVariable != null) {
+      var iteratorType = loopVariable.staticType;
+      var checkedType = iterableType.substitute4([iteratorType]);
+      checkAssignment(expr, checkedType);
+    }
     node.visitChildren(this);
   }
 
   @override
   void visitForStatement(ForStatement node) {
     if (node.condition != null) {
       checkBoolean(node.condition);
     }
     node.visitChildren(this);
   }
@@ skipping 512 matching lines @@
     if (info is CoercionInfo) {
       // TODO(jmesserly): if we're run again on the same AST, we'll produce the
       // same annotations. This should be harmless. This might go away once
       // CodeChecker is integrated better with analyzer, as it will know that
       // checking has already been performed.
       // assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }