Support top-level field declaration and assignment in analyzer2dart.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 549 matching lines @@
 // This is basically a function definition with an empty parameter list and a
 // field element instead of a function element and no const declarations, and
 // never a getter or setter, though that's less important.
 class FieldDefinition extends Node
     implements InteriorNode, ExecutableDefinition {
   final FieldElement element;
   final Continuation returnContinuation;
   Expression body;
 
   FieldDefinition(this.element, this.returnContinuation, this.body);
+
+  FieldDefinition.withoutInitializer(this.element)
+      : this.returnContinuation = null;
+
   accept(Visitor visitor) => visitor.visitFieldDefinition(this);
   applyPass(Pass pass) => pass.rewriteFieldDefinition(this);
+
+  /// `true` if this field has no initializer.
+  ///
+  /// If `true` [body] and [returnContinuation] are `null`.
+  ///
+  /// This is different from a initializer that is `null`. Consider this class:
+  ///
+  ///     class Class {
+  ///       final field;
+  ///       Class.a(this.field);
+  ///       Class.b() : this.field = null;
+  ///       Class.c();
+  ///     }
+  ///
+  /// If `field` had an initializer, possibly `null`, constructors `Class.a` and
+  /// `Class.b` would be invalid, and since `field` has no initializer
+  /// constructor `Class.c` is invalid. We therefore need to distinguish the two
+  /// cases.
+  bool get hasInitializer => body != null;
 }
 
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
 class FunctionDefinition extends Node
     implements InteriorNode, ExecutableDefinition {
   final FunctionElement element;
   final Continuation returnContinuation;
   final List<Parameter> parameters;
   Expression body;
@@ skipping 84 matching lines @@
   // while leaving other nodes for subclasses (i.e., visitLiteralList).
   visitNode(Node node) {
     throw "RecursiveVisitor is stale, add missing visit overrides";
   }
 
   processReference(Reference ref) {}
 
   processFieldDefinition(FieldDefinition node) {}
   visitFieldDefinition(FieldDefinition node) {
     processFieldDefinition(node);
-    visit(node.body);
+    if (node.hasInitializer) {
+      visit(node.body);
+    }
   }
 
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
     node.parameters.forEach(visitParameter);
-    visit(node.body);
+    if (!node.isAbstract) {
+      visit(node.body);
+    }
   }
 
   // Expressions.
 
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     visit(node.body);
   }
@@ skipping 192 matching lines @@
     if (primitive.registerIndex != null) {
       getRegisterArray(primitive.hint).releaseIndex(primitive.registerIndex);
     }
   }
 
   void visitReference(Reference reference) {
     allocate(reference.definition);
   }
 
   void visitFieldDefinition(FieldDefinition node) {
-    visit(node.body);
+    if (node.hasInitializer) {
+      visit(node.body);
+    }
   }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     if (!node.isAbstract) {
       visit(node.body);
     }
     node.parameters.forEach(allocate); // Assign indices to unused parameters.
   }
 
   void visitLetPrim(LetPrim node) {
@@ skipping 97 matching lines @@
   }
 
   // JavaScript specific nodes.
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 }