Support top-level field declaration and assignment in analyzer2dart.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 140 matching lines @@
   ir.FieldDefinition buildField(FieldElement element) {
     assert(invariant(element, element.isImplementation));
     ast.VariableDefinitions definitions = element.node;
     ast.Node fieldDefinition =
         definitions.definitions.nodes.first;
     if (definitions.modifiers.isConst) {
       // TODO(sigurdm): Just return const value.
     }
     assert(fieldDefinition != null);
     assert(elements[fieldDefinition] != null);
-    // This means there is no initializer.
-    // TODO(sigurdm): Avoid ever getting here. Abstract functions and fields
-    // with no initializer should not have a representation in the IR.
-    if (fieldDefinition is! ast.SendSet) return null;
     DetectClosureVariables closureLocals =
     new DetectClosureVariables(elements);
         closureLocals.visit(fieldDefinition);
 
     IrBuilder builder = new IrBuilder(compiler.backend.constantSystem,
         element,
         closureLocals.usedFromClosure);
     return withBuilder(builder, () {
-      ast.SendSet sendSet = fieldDefinition;
-      ir.Primitive result = visit(sendSet.arguments.first);
-      builder.buildReturn(result);
-      return builder.makeFieldDefinition();
+      ir.Primitive initializer;
+      if (fieldDefinition is ast.SendSet) {
+        ast.SendSet sendSet = fieldDefinition;
+        initializer = visit(sendSet.arguments.first);
+      }
+      return builder.makeFieldDefinition(initializer);
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression function = element.node;
     assert(function != null);
     assert(elements[function] != null);
 
     DetectClosureVariables closureLocals = new DetectClosureVariables(elements);
     closureLocals.visit(function);
 
     return withBuilder(
         new IrBuilder(compiler.backend.constantSystem,
                       element, closureLocals.usedFromClosure),
         () {
       FunctionSignature signature = element.functionSignature;
       signature.orderedForEachParameter((ParameterElement parameterElement) {
         irBuilder.createParameter(parameterElement);
       });
 
       List<ConstantExpression> defaults = new List<ConstantExpression>();
       signature.orderedOptionalParameters.forEach((ParameterElement element) {
         defaults.add(getConstantForVariable(element));
       });
 
       visit(function.body);
-      return irBuilder.buildFunctionDefinition(defaults);
+      return irBuilder.makeFunctionDefinition(defaults);
     });
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
@@ skipping 700 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 }