Fixes #287 and other failures statically checking SDK tests

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 136 matching lines @@
 
     // Track types in this strongly connected component, ensure we visit
     // supertypes before subtypes.
     var typeToDeclaration = <InterfaceType, ClassDeclaration>{};
     classes.forEach((c) => typeToDeclaration[c.element.type] = c);
     var seen = new Set<InterfaceType>();
     visit(ClassDeclaration cls) {
       var element = cls.element;
       var type = element.type;
       if (seen.contains(type)) return;
+      seen.add(type);
       for (var supertype in element.allSupertypes) {
         var supertypeClass = typeToDeclaration[supertype];
         if (supertypeClass != null) visit(supertypeClass);
       }
-      seen.add(type);
 
       if (_options.inferFromOverrides) {
         // Infer field types from overrides first, otherwise from initializers.
         var pending = new Set<VariableDeclaration>();
         cls.members
             .where(_isInstanceField)
             .forEach((f) => _inferFieldTypeFromOverride(f, pending));
         if (pending.isNotEmpty) _inferVariableFromInitializer(pending);
 
         // Infer return-types from overrides
@@ skipping 287 matching lines @@
   }
 
   @override
   visitFieldFormalParameter(FieldFormalParameter node) {
     // Ensure the field formal parameter's type is updated after inference.
     // Normally this happens during TypeResolver, but that's before we've done
     // inference on the field type.
     var element = node.element;
     if (element is FieldFormalParameterElement) {
       if (element.type.isDynamic) {
-        element.type = element.field.type;
+        // In malformed code, there may be no actual field.
+        if (element.field != null) {
+          element.type = element.field.type;
+        }
       }
     }
     super.visitFieldFormalParameter(node);
   }
 }
 
 /// Internal state of the resolver, stored so we can reanalyze portions of the
 /// AST quickly, without recomputing everything from the top.
 class _ResolverState {
   final TypePromotionManager_TypePromoteScope promotionScope;
@@ skipping 233 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }