Add support for fields to the new dart backend.

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].
  *
  * The functionality of the IrNodes is added gradually, therefore elements might
  * have an IR or not, depending on the language features that are used. For
  * elements that do have an IR, the tree [ast.Node]s and the [Token]s are not
  * used in the rest of the compilation. This is ensured by setting the element's
  * cached tree to `null` and also breaking the token stream to crash future
  * attempts to parse.
  *
  * The type inferrer works on either IR nodes or tree nodes. The IR nodes are
  * then translated into the SSA form for optimizations and code generation.
  * Long-term, once the IR supports the full language, the backend can be
  * re-implemented to work directly on the IR.
  */
 class IrBuilderTask extends CompilerTask {
-  final Map<Element, ir.FunctionDefinition> nodes =
-      <Element, ir.FunctionDefinition>{};
+  final Map<Element, ir.ExecutableDefinition> nodes =
+      <Element, ir.ExecutableDefinition>{};
 
   IrBuilderTask(Compiler compiler) : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
-  ir.FunctionDefinition getIr(Element element) => nodes[element.implementation];
+  ir.ExecutableDefinition getIr(ExecutableElement element) {
+    return nodes[element.implementation];
+  }
 
-  ir.FunctionDefinition buildNode(AstElement element) {
+  ir.ExecutableDefinition buildNode(AstElement element) {
     if (!canBuild(element)) return null;
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceFile sourceFile = elementSourceFile(element);
       IrBuilderVisitor builder =
           new IrBuilderVisitor(elementsMapping, compiler, sourceFile);
-      return builder.buildFunction(element);
+      return builder.buildExecutable(element);
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach((AstElement element) {
-        ir.FunctionDefinition functionDefinition = buildNode(element);
-        if (functionDefinition != null) {
-          nodes[element] = functionDefinition;
+        ir.ExecutableDefinition definition = buildNode(element);
+        if (definition != null) {
+          nodes[element] = definition;
         }
       });
     });
   }
 
+  bool canBuild(Element element) {
+    if (element is TypedefElement) return false;
+    if (element is FunctionElement) {
+      // TODO(sigurdm): Support native functions for dart2js.
+      assert(invariant(element, !element.isNative));
 
-  bool canBuild(Element element) {
-    FunctionElement function = element.asFunctionElement();
-    // TODO(kmillikin,sigurdm): support lazy field initializers.
-    if (function == null) return false;
+      // TODO(kmillikin,sigurdm): Support constructors.
+      if (element is ConstructorElement) return false;
 
-    if (!compiler.backend.shouldOutput(function)) return false;
-
-    assert(invariant(element, !function.isNative));
-
-    // TODO(kmillikin,sigurdm): Support constructors.
-    if (function is ConstructorElement) return false;
-
-    return true;
+    } else if (element is! FieldElement) {
+      compiler.internalError(element, "Unexpected elementtype $element");
+    }
+    return compiler.backend.shouldOutput(element);
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
   SourceFile elementSourceFile(Element element) {
     if (element is FunctionElement) {
@@ skipping 38 matching lines @@
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
       : super(elements);
 
   /**
-   * Builds the [ir.FunctionDefinition] for a function element. In case the
-   * function uses features that cannot be expressed in the IR, this function
+   * Builds the [ir.ExecutableDefinition] for an executable element. In case the
+   * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
-  ir.FunctionDefinition buildFunction(FunctionElement functionElement) {
-    return nullIfGiveup(() => buildFunctionInternal(functionElement));
+  ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
+    return nullIfGiveup(() {
+      if (element is FieldElement) {
+        return buildField(element);
+      } else if (element is FunctionElement) {
+        return buildFunction(element);
+      } else {
+        compiler.internalError(element, "Unexpected element type $element");
+      }
+    });
   }
 
-  ir.FunctionDefinition buildFunctionInternal(FunctionElement element) {
+  /// Returns a [ir.FieldDefinition] describing the initializer of [element].
+  /// Returns `null` if [element] has no initializer.
+  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.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(element, defaults);
+      return irBuilder.buildFunctionDefinition(defaults);
     });
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
@@ skipping 624 matching lines @@
 
   ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(irBuilder.isOpen);
     if (constant == null) {
       constant = getConstantForNode(node);
     }
     return irBuilder.buildConstantLiteral(constant);
   }
 
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
-    return buildFunctionInternal(elements[node]);
+    return buildFunction(elements[node]);
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
     return irBuilder.buildFunctionExpression(makeSubFunction(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     ir.FunctionDefinition inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   dynamic giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
 
-  ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
+  ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
@@ skipping 36 matching lines @@
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 }