dart2js cps: Introduce GetStatic/SetStatic.

pkg/compiler/lib/src/js_backend/codegen/codegen.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 code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../js/js.dart' as js;
@@ skipping 222 matching lines @@
       return js.propertyCall(interceptorLibrary, selector.name, arguments);
     } else {
       js.Expression elementAccess = glue.staticFunctionAccess(target);
       return new js.Call(elementAccess, arguments,
           sourceInformation: sourceInformation);
     }
   }
 
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
-    checkStaticTargetIsValid(node, node.target);
     if (node.constant != null) return giveup(node);
 
     registry.registerInstantiatedType(node.type);
     Selector selector = node.selector;
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitArguments(node.arguments);
     return buildStaticInvoke(selector, target, arguments);
   }
 
   void registerMethodInvoke(tree_ir.InvokeMethod node) {
@@ skipping 15 matching lines @@
   }
 
   @override
   js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
     registerMethodInvoke(node);
     return js.propertyCall(visitExpression(node.receiver),
                            glue.invocationName(node.selector),
                            visitArguments(node.arguments));
   }
 
-  /// Checks that the target of the static call is not an [ErroneousElement].
-  ///
-  /// This helper should be removed and the code to generate the CPS IR for
-  /// the dart2js backend should construct a call to a helper that throw an
-  /// appropriate error message instead of the static call.
-  ///
-  /// See [SsaBuilder.visitStaticSend] as an example how to do this.
-  void checkStaticTargetIsValid(tree_ir.Node node, Element target) {
-    if (target.isErroneous) {
-      giveup(node, 'cannot generate error handling code'
-                   ' for call to unresolved target');
-    }
-  }
-
   @override
   js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
-    checkStaticTargetIsValid(node, node.target);
     Selector selector = node.selector;
-    if (node.target is FunctionElement) {
-      assert(selector.isGetter || selector.isSetter || selector.isCall);
-      FunctionElement target = node.target;
-      List<js.Expression> arguments = visitArguments(node.arguments);
-      return buildStaticInvoke(selector, target, arguments,
-          sourceInformation: node.sourceInformation);
-    } else {
-      assert(selector.isGetter || selector.isSetter);
-      FieldElement target = node.target;
-      registry.registerStaticUse(target);
-      js.Expression field = glue.staticFieldAccess(target);
-      if (selector.isGetter) {
-        assert(node.arguments.isEmpty);
-        return field;
-      } else {
-        assert(node.arguments.length == 1);
-        js.Expression value = visitExpression(node.arguments.first);
-        return new js.Assignment(field, value);
-      }
-    }
+    assert(selector.isGetter || selector.isSetter || selector.isCall);
+    FunctionElement target = node.target;
+    List<js.Expression> arguments = visitArguments(node.arguments);
+    return buildStaticInvoke(selector, target, arguments,
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeMethodDirectly(tree_ir.InvokeMethodDirectly node) {
     registry.registerDirectInvocation(node.target.declaration);
     if (node.target is ConstructorBodyElement) {
       // A constructor body cannot be overriden or intercepted, so we can
       // use the short form for this invocation.
       return js.js('#.#(#)',
           [visitExpression(node.receiver),
@@ skipping 284 matching lines @@
 
   @override
   js.Assignment visitSetField(tree_ir.SetField node) {
     js.PropertyAccess field =
         new js.PropertyAccess.field(
             visitExpression(node.object),
             glue.instanceFieldPropertyName(node.field));
     return new js.Assignment(field, visitExpression(node.value));
   }
 
+  @override
+  js.Expression visitGetStatic(tree_ir.GetStatic node) {
+    assert(node.element is FieldElement || node.element is FunctionElement);
+    if (node.element is FieldElement) {
+      registry.registerStaticUse(node.element.declaration);
+      return glue.staticFieldAccess(node.element);
+    } else {
+      registry.registerGetOfStaticFunction(node.element.declaration);
+      return glue.isolateStaticClosureAccess(node.element);
+    }
+  }
+
+  @override
+  js.Expression visitSetStatic(tree_ir.SetStatic node) {
+    assert(node.element is FieldElement);
+    registry.registerStaticUse(node.element.declaration);
+    js.Expression field = glue.staticFieldAccess(node.element);
+    js.Expression value = visitExpression(node.value);
+    return new js.Assignment(field, value);
+  }
+
   js.Expression buildStaticHelperInvocation(FunctionElement helper,
                                             List<js.Expression> arguments) {
     registry.registerStaticUse(helper);
     return buildStaticInvoke(new Selector.fromElement(helper), helper,
         arguments);
   }
 
   @override
   js.Expression visitReifyRuntimeType(tree_ir.ReifyRuntimeType node) {
     FunctionElement createType = glue.getCreateRuntimeType();
@@ skipping 45 matching lines @@
 
   @override
   visitVariableDeclaration(tree_ir.VariableDeclaration node) {
     return errorUnsupportedNode(node);
   }
 
   errorUnsupportedNode(tree_ir.DartSpecificNode node) {
     throw "Unsupported node in JS backend: $node";
   }
 }