Start new design for interceptors and implement String.charCodeAt with it.

sdk/lib/_internal/compiler/implementation/js_backend/backend.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 628 matching lines @@
       : types = new HTypeMap(),
         boundsChecked = new Set<HInstruction>();
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
+  ClassElement jsStringClass;
+  ClassElement objectInterceptorClass;
+  Element getInterceptorMethod;
+
   final Namer namer;
 
   /**
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
    */
   ClassElement jsIndexingBehaviorInterface;
 
   final Map<Element, ReturnInfo> returnInfo;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: Elements must be declaration elements.
    */
   final List<Element> invalidateAfterCodegen;
   ArgumentTypesRegistry argumentTypes;
   FieldTypesRegistry fieldTypes;
 
   final Interceptors interceptors;
 
+  /**
+   * A collection of selectors of intercepted method calls. The
+   * emitter uses this set to generate the [:ObjectInterceptor:] class
+   * whose members just forward the call to the intercepted receiver.
+   */
+  final Set<Selector> usedInterceptors;
+
+  /**
+   * The members of instantiated interceptor classes: maps a member
+   * name to the list of members that have that name. This map is used
+   * by the codegen to know whether a send must be intercepted or not.
+   */
+  final Map<SourceString, List<Element>> interceptedElements;  
+
   List<CompilerTask> get tasks {
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   JavaScriptBackend(Compiler compiler,
                     bool generateSourceMap,
                     bool disableEval)
       : namer = new Namer(compiler),
         returnInfo = new Map<Element, ReturnInfo>(),
         invalidateAfterCodegen = new List<Element>(),
         interceptors = new Interceptors(compiler),
+        usedInterceptors = new Set<Selector>(),
+        interceptedElements = new Map<SourceString, List<Element>>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
     argumentTypes = new ArgumentTypesRegistry(this);
     fieldTypes = new FieldTypesRegistry(this);
   }
 
+  bool isInterceptorClass(Element element) {
+    return element == jsStringClass;
+  }
+
+  void addInterceptedSelector(Selector selector) {
+    usedInterceptors.add(selector);
+  }
+
+  bool shouldInterceptSelector(Selector selector) {
+    List<Element> intercepted = interceptedElements[selector.name];
+    if (intercepted == null) return false;
+    for (Element element in intercepted) {
+      if (selector.applies(element, compiler)) return true;
+    }
+    return false;
+  }
+
+
+  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
+    ClassElement result = null;
+    if (cls == compiler.stringClass) {
+      if (jsStringClass == null) {
+        jsStringClass =
+            compiler.findInterceptor(const SourceString('JSString'));
+        objectInterceptorClass =
+            compiler.findInterceptor(const SourceString('ObjectInterceptor'));
+        getInterceptorMethod =
+            compiler.findInterceptor(const SourceString('getInterceptor'));
+      }
+      result = jsStringClass;
+    }
+
+    if (result == null) return;
+
+    result.forEachMember((_, Element member) {
+      List<Element> list = interceptedElements.putIfAbsent(
+          member.name, () => new List<Element>());
+      list.add(member);
+    });
+
+    enqueuer.registerInstantiatedClass(result);
+  }
+
   Element get cyclicThrowHelper {
     return compiler.findHelper(const SourceString("throwCyclicInit"));
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   Element getInterceptor(Selector selector) {
     return interceptors.getStaticInterceptor(selector);
@@ skipping 249 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }