Support static field access in analyzer2dart.

sdk/lib/_internal/compiler/implementation/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import 'cps_ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 332 matching lines @@
     return buildPrimConst(
         constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a get access of [local].
   ir.Primitive buildGetLocal(Element local) {
     assert(isOpen);
     return environment.lookup(local);
   }
 
+  /// Create a get access of the static [element].
+  ir.Primitive buildGetStatic(Element element, Selector selector) {
+    assert(isOpen);
+    assert(selector.isGetter);
+    return continueWithExpression(
+        (k) => new ir.InvokeStatic(element, selector, k, []));
+  }
+
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = makePrimConst(constantSystem.createNull());
     add(new ir.LetPrim(constant));
     add(new ir.InvokeContinuation(returnContinuation, [constant]));
@@ skipping 1068 matching lines @@
       LocalElement local = element;
       result = new ir.GetClosureVariable(local);
       add(new ir.LetPrim(result));
     } else if (Elements.isLocal(element)) {
       // Reference to local variable
       result = buildGetLocal(element);
     } else if (element == null ||
                Elements.isInstanceField(element) ||
                Elements.isInstanceMethod(element) ||
                selector.isIndex ||
-               // TODO(johnniwinther): clean up semantics of resultion.
+               // TODO(johnniwinther): clean up semantics of resolution.
                node.isSuperCall) {
       // Dynamic dispatch to a getter. Sometimes resolution will suggest a
       // target element, but in these cases we must still emit a dynamic
       // dispatch. The target element may be an instance method in case we are
       // converting a method to a function object.
 
       receiver = visitReceiver(node.receiver);
       List<ir.Primitive> arguments = new List<ir.Primitive>();
       if (selector.isIndex) {
         index = visit(node.arguments.head);
         arguments.add(index);
       }
 
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.INDEX);
       result = continueWithExpression(
           (k) => createDynamicInvoke(node, selector, receiver, k, arguments));
     } else if (element.isField || element.isGetter || element.isErroneous ||
                element.isSetter) {
       // Access to a static field or getter (non-static case handled above).
       // Even if there is only a setter, we compile as if it was a getter,
       // so the vm can fail at runtime.
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);

[sigurdm, 2014/09/29 08:59:42]

Not your code, but it seems we should here only check for getters.

[Johnni Winther, 2014/09/29 13:07:25]

Added a TODO.

-      result = continueWithExpression(
-          (k) => new ir.InvokeStatic(element, selector, k, []));
+      result = buildGetStatic(element, selector);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // Convert a top-level or static function to a function object.
       result = translateConstant(node);
     } else {
       throw "Unexpected SendSet getter: $node, $element";
     }
     return new _GetterElements(
         result: result,index: index, receiver: receiver);
   }
 
@@ skipping 625 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }