dart2js: Add interceptors to new emitter.

sdk/lib/_internal/compiler/implementation/js_emitter/program_builder.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.js_emitter.program_builder;
 
 import 'model.dart';
 import '../common.dart';
 import '../js/js.dart' as js;
 
 import '../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
-import '../js_emitter/js_emitter.dart' as emitterTask show
+import 'js_emitter.dart' as emitterTask show
     CodeEmitterTask,
-    Emitter;
+    Emitter,
+    InterceptorStubGenerator;
 
 import '../universe/universe.dart' show Universe;
 import '../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
 part 'registry.dart';
 
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
   final emitterTask.CodeEmitterTask _task;
@@ skipping 153 matching lines @@
     String uri = library.canonicalUri.toString();
 
     List<StaticMethod> statics = elements
         .where((e) => e is FunctionElement).map(_buildStaticMethod).toList();
 
     statics.addAll(elements
         .where((e) => e is FunctionElement)
         .where((e) => universe.staticFunctionsNeedingGetter.contains(e))
         .map(_buildStaticMethodTearOff));
 
+    if (library == backend.interceptorsLibrary) {
+      statics.addAll(_generateGetInterceptorMethods());
+      statics.addAll(_generateOneShotInterceptors());
+    }
+
     List<Class> classes = elements
         .where((e) => e is ClassElement)
         .map(_buildClass)
         .toList(growable: false);
 
     return new Library(uri, statics, classes);
   }
 
   Class _buildClass(ClassElement element) {
     List<Method> methods = [];
@@ skipping 12 matching lines @@
     Class result = new Class(name, _registry.registerHolder(holder), methods);
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
     return new Method(name, code);
   }
 
+  Iterable<StaticMethod> _generateGetInterceptorMethods() {
+    emitterTask.InterceptorStubGenerator stubGenerator =
+        new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
+
+    String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
+    Holder holder = _registry.registerHolder(holderName);
+
+    Map<String, Set<ClassElement>> specializedGetInterceptors =
+        backend.specializedGetInterceptors;
+    List<String> names = specializedGetInterceptors.keys.toList()..sort();
+    return names.map((String name) {
+      Set<ClassElement> classes = specializedGetInterceptors[name];
+      js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
+      return new StaticMethod(name, holder, code);
+    });
+  }
+
+  Iterable<StaticMethod> _generateOneShotInterceptors() {
+    emitterTask.InterceptorStubGenerator stubGenerator =
+        new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
+
+    String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
+    Holder holder = _registry.registerHolder(holderName);
+
+    List<String> names = backend.oneShotInterceptors.keys.toList()..sort();
+    return names.map((String name) {
+      js.Expression code = stubGenerator.generateOneShotInterceptor(name);
+      return new StaticMethod(name, holder, code);
+    });
+  }
+
   StaticMethod _buildStaticMethod(FunctionElement element) {
     String name = namer.getNameOfMember(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
     return new StaticMethod(name, _registry.registerHolder(holder), code);
   }
 
   StaticMethod _buildStaticMethodTearOff(FunctionElement element) {
     String name = namer.getStaticClosureName(element);
     String holder = namer.globalObjectFor(element);
     // TODO(kasperl): This clearly doesn't work yet.
     js.Expression code = js.string("<<unimplemented>>");
     return new StaticMethod(name, _registry.registerHolder(holder), code);
   }
 
   void _registerConstants(OutputUnit outputUnit,
                           List<ConstantValue> constantValues) {
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     };
   }
 }