Support intercepted getters, setters and index operations.

pkg/compiler/lib/src/js_backend/codegen/glue.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_dependencies;
 
 import '../js_backend.dart';
 import '../../dart2jslib.dart';
 import '../../js_emitter/js_emitter.dart';
 import '../../js/js.dart' as js;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../constants/expressions.dart';
 import '../../closure.dart' show ClosureClassElement;
+import '../../universe/universe.dart' show SelectorKind;
+
+/// A non-call selector translated to JavaScript call semantics.
+///
+/// The name of the this selector is already the correct JavaScript target name
+/// as translated by the namer.
+class JsCallSelector extends Selector {
+  /// The selector from which this selector originated. This selector is used
+  /// to identify possible targets using Dart semantics.
+  final Selector source;
+  JsCallSelector(Selector source,
+                 String name,
+                 int arity,
+                 List<String> namedArguments)
+      : this.source = source,
+        super.internal(SelectorKind.CALL, name, null, arity, namedArguments,
+          <String>[], source.hashCode * 13 + name.hashCode);
+}
 
 /// Encapsulates the dependencies of the function-compiler to the compiler,
 /// backend and emitter.
 // TODO(sigurdm): Should be refactored when we have a better feeling for the
 // interface.
 class Glue {
   final Compiler _compiler;
 
   JavaScriptBackend get _backend => _compiler.backend;
 
@@ skipping 28 matching lines @@
     return _backend.mapLiteralConstructor;
   }
 
   ConstructorElement get mapLiteralConstructorEmpty {
     return _backend.mapLiteralConstructorEmpty;
   }
 
   FunctionElement get identicalFunction => _compiler.identicalFunction;
 
   String invocationName(Selector selector) {
+    if (selector is JsCallSelector) {
+      return selector.name;
+    }
     return _namer.invocationName(selector);
   }
 
   FunctionElement get getInterceptorMethod => _backend.getInterceptorMethod;
 
   void registerUseInterceptorInCodegen() {
     _backend.registerUseInterceptor(_compiler.enqueuer.codegen);
   }
 
   bool isInterceptedSelector(Selector selector) {
@@ skipping 15 matching lines @@
   String instanceFieldPropertyName(Element field) {
     return _namer.instanceFieldPropertyName(field);
   }
 
   js.Expression prototypeAccess(ClassElement e,
                                 {bool hasBeenInstantiated: false}) {
     return _emitter.prototypeAccess(e,
         hasBeenInstantiated: hasBeenInstantiated);
   }
 
+
+  String getInterceptorName(Set<ClassElement> interceptedClasses) {
+    return _backend.namer.getInterceptorName(
+        getInterceptorMethod,
+        interceptedClasses);
+  }
+
+  js.Expression getInterceptorLibrary() {
+    return new js.VariableUse(
+        _backend.namer.globalObjectFor(_backend.interceptorsLibrary));
+  }
 }