Type check field initializers in the correct context.

pkg/compiler/lib/src/typechecker.dart

 // Copyright (c) 2012, 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 dart2js.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 46 matching lines @@
   void check(AstElement element) {
     if (element.isClass) return;
     if (element.isTypedef) return;
     ResolvedAst resolvedAst = element.resolvedAst;
     reporter.withCurrentElement(element.implementation, () {
       measure(() {
         TypeCheckerVisitor visitor = new TypeCheckerVisitor(
             compiler, resolvedAst.elements, compiler.types);
         if (element.isField) {
           visitor.analyzingInitializer = true;
+          DartType type =
+              visitor.analyzeVariableTypeAnnotation(resolvedAst.node);
+          visitor.analyzeVariableInitializer(element, type, resolvedAst.body);
+        } else {
+          resolvedAst.node.accept(visitor);
         }
-        resolvedAst.node.accept(visitor);
       });
     });
   }
 }
 
 /**
  * Class used to report different warnings for different kinds of members.
  */
 class MemberKind {
   static const MemberKind METHOD = const MemberKind("method");
@@ skipping 1555 matching lines @@
     return constructorType;
   }
 
   DartType visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (Elements.isUnresolved(element)) return const DynamicType();
 
     checkPrivateAccess(node, element, element.name);
 
     DartType newType = elements.getType(node);
+    assert(invariant(node, newType != null,
+        message: "No new type registered in $elements."));
     DartType constructorType = computeConstructorType(element, newType);
     analyzeArguments(node.send, element, constructorType);
     return newType;
   }
 
   DartType visitLiteralList(LiteralList node) {
     InterfaceType listType = elements.getType(node);
     DartType listElementType = firstType(listType.typeArguments);
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
@@ skipping 97 matching lines @@
     }
     // The static type of the result must be assignable to the declared type.
     checkAssignable(node, resultType, expectedReturnType);
     return const StatementType();
   }
 
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return elements.getType(node);
   }
 
-  DartType visitVariableDefinitions(VariableDefinitions node) {
+  DartType analyzeVariableTypeAnnotation(VariableDefinitions node) {
     DartType type = analyzeWithDefault(node.type, const DynamicType());
     if (type.isVoid) {
       reportTypeWarning(node.type, MessageKind.VOID_VARIABLE);
       type = const DynamicType();
     }
+    return type;
+  }
+
+  void analyzeVariableInitializer(
+      Spannable spannable, DartType declaredType, Node initializer) {
+    if (initializer == null) return;
+    
+    DartType expressionType = analyzeNonVoid(initializer);
+    checkAssignable(spannable, expressionType, declaredType);
+  }
+
+  DartType visitVariableDefinitions(VariableDefinitions node) {
+    DartType type = analyzeVariableTypeAnnotation(node);
     for (Link<Node> link = node.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       Node definition = link.head;
       invariant(definition, definition is Identifier || definition is SendSet,
           message: 'expected identifier or initialization');
       if (definition is SendSet) {
         SendSet initialization = definition;
-        DartType initializer = analyzeNonVoid(initialization.arguments.head);
-        checkAssignable(initialization.assignmentOperator, initializer, type);
+        analyzeVariableInitializer(
+            initialization.assignmentOperator,
+            type,
+            initialization.arguments.head);
         // TODO(sigmund): explore inferring a type for `var` using the RHS (like
         // DDC does), for example:
         // if (node.type == null && node.modifiers.isVar &&
         //     !initializer.isDynamic) {
         //   var variable = elements[definition];
         //   if (variable != null) {
         //     var typePromotion = new TypePromotion(
         //         node, variable, initializer);
         //     registerKnownTypePromotion(typePromotion);
         //   }
@@ skipping 241 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }