dart2js cps: Do field calls directly instead going through the adapter.

pkg/compiler/lib/src/cps_ir/type_propagation.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 dart2js.cps_ir.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement;
 import '../common.dart';
@@ skipping 1427 matching lines @@
   }
 
   bool isInterceptedSelector(Selector selector) {
     return backend.isInterceptedSelector(selector);
   }
 
   /// If [node] is a getter or setter invocation, tries to replace the
   /// invocation with a direct access to a field.
   ///
   /// Returns `true` if the node was replaced.
-  Primitive specializeFieldAccess(InvokeMethod node) {
-    if (!node.selector.isGetter && !node.selector.isSetter) return null;
+  specializeFieldAccess(InvokeMethod node) {
     AbstractConstantValue receiver = getValue(node.receiver);
     Element target =
         typeSystem.locateSingleElement(receiver.type, node.selector);
     if (target is! FieldElement) return null;
     // TODO(asgerf): Inlining native fields will make some tests pass for the
     // wrong reason, so for testing reasons avoid inlining them.
     if (backend.isNative(target) || backend.isJsInterop(target)) {
       return null;
     }
     if (node.selector.isGetter) {
       return new GetField(node.receiver, target);
-    } else {
+    } else if (node.selector.isSetter) {
       if (target.isFinal) return null;
       assert(node.hasNoUses);
       return new SetField(node.receiver,
                           target,
                           node.argument(0));
+    } else if (node.selector.isCall) {
+      CpsFragment cps = new CpsFragment(node.sourceInformation);
+      Primitive fieldValue = cps.letPrim(new GetField(node.receiver, target));
+      Primitive result = cps.invokeMethod(
+          fieldValue,
+          new Selector.callClosureFrom(node.selector),
+          typeSystem.getFieldType(target),
+          node.arguments.toList());
+      node.replaceUsesWith(result);
+      return cps;
+    } else {
+      return null;
     }
   }
 
   /// Create a check that throws if [index] is not a valid index on [list].
   ///
   /// This function assumes that [index] is an integer.
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
   Primitive makeBoundsCheck(CpsFragment cps,
@@ skipping 2070 matching lines @@
   }
 
   Primitive makeCheck(CpsFragment cps, Primitive value) {
     return cps.applyBuiltin(negatedOperator, [value]);
   }
 
   Primitive makeRefinement(CpsFragment cps, Primitive value, World world) {
     return cps.refine(value, new TypeMask.nonNullSubclass(classElement, world));
   }
 }