Support top-level field declaration and assignment in analyzer2dart.

pkg/analyzer2dart/lib/src/cps_generator.dart

 // Copyright (c) 2014, 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 analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/src/dart_types.dart' as dart2js;
 import 'package:compiler/src/elements/elements.dart' as dart2js;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/element.dart' as analyzer;
 
 import 'package:compiler/src/dart2jslib.dart'
     show DART_CONSTANT_SYSTEM;
 import 'package:compiler/src/cps_ir/cps_ir_nodes.dart' as ir;
 import 'package:compiler/src/cps_ir/cps_ir_builder.dart';
 import 'package:compiler/src/universe/universe.dart';
 
 import 'semantic_visitor.dart';
 import 'element_converter.dart';
 import 'util.dart';
 import 'identifier_semantics.dart';
 
+/// Visitor that converts the AST node of an analyzer element into a CPS ir
+/// node.
+class CpsElementVisitor extends analyzer.SimpleElementVisitor<ir.Node> {
+  final ElementConverter converter;
+  final AstNode node;
+
+  CpsElementVisitor(this.converter, this.node);
+
+  @override
+  ir.FunctionDefinition visitFunctionElement(analyzer.FunctionElement element) {
+    CpsGeneratingVisitor visitor = new CpsGeneratingVisitor(converter, element);
+    FunctionDeclaration functionDeclaration = node;
+    return visitor.handleFunctionDeclaration(
+        element, functionDeclaration.functionExpression);
+  }
+
+  @override
+  ir.FieldDefinition visitTopLevelVariableElement(
+      analyzer.TopLevelVariableElement element) {
+    CpsGeneratingVisitor visitor = new CpsGeneratingVisitor(converter, element);
+    VariableDeclaration variableDeclaration = node;
+    return visitor.handleFieldDeclaration(element, variableDeclaration);
+  }
+}
+
+/// Visitor that converts analyzer AST nodes into CPS ir nodes.
 class CpsGeneratingVisitor extends SemanticVisitor<ir.Node>
     with IrBuilderMixin<AstNode> {
   final analyzer.Element element;
   final ElementConverter converter;
 
   CpsGeneratingVisitor(this.converter, this.element);
 
   Source get currentSource => element.source;
 
   analyzer.LibraryElement get currentLibrary => element.library;
 
   ir.Node visit(AstNode node) => node.accept(this);
 
-  @override
-  ir.Primitive visitFunctionExpression(FunctionExpression node) {
-    return irBuilder.buildFunctionExpression(
-        handleFunctionDeclaration(node.element, node));
+  ir.FieldDefinition handleFieldDeclaration(
+      analyzer.PropertyInducingElement field, VariableDeclaration node) {
+    dart2js.FieldElement element = converter.convertElement(field);
+    return withBuilder(
+        new IrBuilder(DART_CONSTANT_SYSTEM,
+                      element,
+                      // TODO(johnniwinther): Supported closure variables.
+                      const <dart2js.Local>[]),
+        () {
+      ir.Primitive initializer = build(node.initializer);
+      return irBuilder.makeFieldDefinition(initializer);
+    });
   }
 
   ir.FunctionDefinition handleFunctionDeclaration(
       analyzer.FunctionElement function, FunctionExpression node) {
     dart2js.FunctionElement element = converter.convertElement(function);
     return withBuilder(
         new IrBuilder(DART_CONSTANT_SYSTEM,
                       element,
                       // TODO(johnniwinther): Supported closure variables.
                       const <dart2js.Local>[]),
         () {
       function.parameters.forEach((analyzer.ParameterElement parameter) {
         // TODO(johnniwinther): Support "closure variables", that is variables
         // accessed from an inner function.
         irBuilder.createParameter(converter.convertElement(parameter));
       });
       // Visit the body directly to avoid processing the signature as
       // expressions.
       visit(node.body);
-      return irBuilder.buildFunctionDefinition(const []);
+      return irBuilder.makeFunctionDefinition(const []);
     });
   }
 
   @override
+  ir.Primitive visitFunctionExpression(FunctionExpression node) {
+    return irBuilder.buildFunctionExpression(
+        handleFunctionDeclaration(node.element, node));
+  }
+
+  @override
   ir.FunctionDefinition visitFunctionDeclaration(FunctionDeclaration node) {
     return handleFunctionDeclaration(node.element, node.functionExpression);
   }
 
   @override
   visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     FunctionDeclaration functionDeclaration = node.functionDeclaration;
     analyzer.FunctionElement function = functionDeclaration.element;
     dart2js.FunctionElement element = converter.convertElement(function);
     ir.FunctionDefinition definition = handleFunctionDeclaration(
@@ skipping 209 matching lines @@
     return handleLocalAssignment(node, semantics);
   }
 
   @override
   ir.Node visitParameterAssignment(AssignmentExpression node,
                                    AccessSemantics semantics) {
     return handleLocalAssignment(node, semantics);
   }
 
   @override
+  ir.Node visitStaticFieldAssignment(AssignmentExpression node,
+                                     AccessSemantics semantics) {
+    if (node.operator.lexeme != '=') {
+      return giveUp(node, 'Assignment operator: ${node.operator.lexeme}');
+    }
+    analyzer.Element element = semantics.element;
+    dart2js.Element target = converter.convertElement(element);
+    // TODO(johnniwinther): Selector information should be computed in the
+    // [TreeShaker] and shared with the [CpsGeneratingVisitor].
+    assert(invariant(node, target.isTopLevel || target.isStatic,
+                     '$target expected to be top-level or static.'));
+    return irBuilder.buildStaticSet(
+        target,
+        new Selector.setter(target.name, target.library),
+        build(node.rightHandSide));
+  }
+
+  @override
   ir.Node visitDynamicAccess(AstNode node, AccessSemantics semantics) {
     // TODO(johnniwinther): Handle implicit `this`.
     ir.Primitive receiver = build(semantics.target);
     return irBuilder.buildDynamicGet(receiver,
         new Selector.getter(semantics.identifier.name,
                             converter.convertElement(element.library)));
   }
 
   @override
   ir.Node visitStaticFieldAccess(AstNode node, AccessSemantics semantics) {
@@ skipping 151 matching lines @@
   }
 
   @override
   ir.Primitive visitAsExpression(AsExpression node) {
     return irBuilder.buildTypeOperator(
         visit(node.expression),
         converter.convertType(node.type.type),
         isTypeTest: false);
   }
 }