feat(dart/transform): Use the Dart transformer for benchmarks

Remove explicit generation of reflection information in benchmark code
and generate it with the transformer.

modules/benchmarks/src/tree/tree_benchmark.js

@@ -20,6 +20,7 @@ import {DynamicComponentLoader} from 'angular2/src/core/compiler/dynamic_compone
 import {TestabilityRegistry, Testability} from 'angular2/src/core/testability/testability';
 
 import {reflector} from 'angular2/src/reflection/reflection';
+import {ReflectionCapabilities} from 'angular2/src/reflection/reflection_capabilities';
 import {DOM} from 'angular2/src/dom/dom_adapter';
 import {isPresent} from 'angular2/src/facade/lang';
 import {window, document, gc} from 'angular2/src/facade/browser';
@@ -38,245 +39,14 @@ import {Renderer} from 'angular2/src/render/api';
 import {DirectDomRenderer} from 'angular2/src/render/dom/direct_dom_renderer';
 import * as rc from 'angular2/src/render/dom/compiler/compiler';
 import * as rvf from 'angular2/src/render/dom/view/view_factory';
-import {Inject} from 'angular2/di';
+import {Inject, bind} from 'angular2/di';
+
+function createBindings():List {
+  return [bind(VIEW_POOL_CAPACITY).toValue(100000)];
+}
 
 function setupReflector() {
-  // TODO: Put the general calls to reflector.register... in a shared file
-  // as they are needed in all benchmarks...
-
-  reflector.registerType(AppComponent, {
-    'factory': () => new AppComponent(),
-    'parameters': [],
-    'annotations' : [
-      new Component({selector: 'app'}),
-      new View({
-        directives: [TreeComponent],
-        template: `<tree [data]='initData'></tree>`
-      })]
-  });
-
-  reflector.registerType(TreeComponent, {
-    'factory': () => new TreeComponent(),
-    'parameters': [],
-    'annotations' : [
-      new Component({
-        selector: 'tree',
-        properties: {'data': 'data'}
-      }),
-      new View({
-        directives: [TreeComponent, If],
-        template: `<span> {{data.value}} <span template='if data.right != null'><tree [data]='data.right'></tree></span><span template='if data.left != null'><tree [data]='data.left'></tree></span></span>`
-      })]
-  });
-
-  reflector.registerType(If, {
-    'factory': (vp) => new If(vp),
-    'parameters': [[ViewContainer]],
-    'annotations' : [new Viewport({
-      selector: '[if]',
-      properties: {
-        'condition': 'if'
-      }
-    })]
-  });
-
-  reflector.registerType(Compiler, {
-    "factory": (reader, compilerCache, tplResolver, cmpUrlMapper, urlResolver, renderer,
-                protoViewFactory) =>
-      new Compiler(reader, compilerCache, tplResolver, cmpUrlMapper, urlResolver, renderer,
-                protoViewFactory),
-    "parameters": [[DirectiveMetadataReader], [CompilerCache], [TemplateResolver], [ComponentUrlMapper],
-                   [UrlResolver], [Renderer], [ProtoViewFactory]],
-    "annotations": []
-  });
-
-  reflector.registerType(CompilerCache, {
-    'factory': () => new CompilerCache(),
-    'parameters': [],
-    'annotations': []
-  });
-
-  reflector.registerType(Parser, {
-    'factory': (lexer) => new Parser(lexer),
-    'parameters': [[Lexer]],
-    'annotations': []
-  });
-
-  reflector.registerType(TemplateLoader, {
-    'factory': (xhr, urlResolver) => new TemplateLoader(xhr, urlResolver),
-    'parameters': [[XHR], [UrlResolver]],
-    'annotations': []
-  });
-
-  reflector.registerType(TemplateResolver, {
-    'factory': () => new TemplateResolver(),
-    'parameters': [],
-    'annotations': []
-  });
-
-  reflector.registerType(XHR, {
-    'factory': () => new XHRImpl(),
-    'parameters': [],
-    'annotations': []
-  });
-
-  reflector.registerType(DirectiveMetadataReader, {
-    'factory': () => new DirectiveMetadataReader(),
-    'parameters': [],
-    'annotations': []
-  });
-
-  reflector.registerType(ShadowDomStrategy, {
-    "factory": (strategy) => strategy,
-    "parameters": [[NativeShadowDomStrategy]],
-    "annotations": []
-  });
-
-  reflector.registerType(NativeShadowDomStrategy, {
-    "factory": (styleUrlResolver) => new NativeShadowDomStrategy(styleUrlResolver),
-    "parameters": [[StyleUrlResolver]],
-    "annotations": []
-  });
-
-  reflector.registerType(EmulatedUnscopedShadowDomStrategy, {
-    "factory": (styleUrlResolver) => new EmulatedUnscopedShadowDomStrategy(styleUrlResolver, null),
-    "parameters": [[StyleUrlResolver]],
-    "annotations": []
-  });
-
-  reflector.registerType(TestabilityRegistry, {
-    "factory": () => new TestabilityRegistry(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(Testability, {
-    "factory": () => new Testability(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(StyleUrlResolver, {
-    "factory": (urlResolver) => new StyleUrlResolver(urlResolver),
-    "parameters": [[UrlResolver]],
-    "annotations": []
-  });
-
-  reflector.registerType(UrlResolver, {
-    "factory": () => new UrlResolver(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(Lexer, {
-    'factory': () => new Lexer(),
-    'parameters': [],
-    'annotations': []
-  });
-
-  reflector.registerType(ExceptionHandler, {
-    "factory": () => new ExceptionHandler(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(LifeCycle, {
-    "factory": (exHandler, cd) => new LifeCycle(exHandler, cd),
-    "parameters": [[ExceptionHandler], [ChangeDetector]],
-    "annotations": []
-  });
-
-  reflector.registerType(ComponentUrlMapper, {
-    "factory": () => new ComponentUrlMapper(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(StyleInliner, {
-    "factory": (xhr, styleUrlResolver, urlResolver) =>
-      new StyleInliner(xhr, styleUrlResolver, urlResolver),
-    "parameters": [[XHR], [StyleUrlResolver], [UrlResolver]],
-    "annotations": []
-  });
-
-  reflector.registerType(EventManager, {
-    "factory": () => new EventManager([], null),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(DynamicComponentLoader, {
-    "factory": (compiler, reader, renderer, viewFactory) =>
-      new DynamicComponentLoader(compiler, reader, renderer, viewFactory),
-    "parameters": [[Compiler], [DirectiveMetadataReader], [Renderer], [ViewFactory]],
-    "annotations": []
-  });
-  
-  reflector.registerType(DirectDomRenderer, {
-    "factory": (renderCompiler, renderViewFactory, shadowDomStrategy) =>
-      new DirectDomRenderer(renderCompiler, renderViewFactory, shadowDomStrategy),
-    "parameters": [[rc.Compiler], [rvf.ViewFactory], [ShadowDomStrategy]],
-    "annotations": []
-  });
-
-  reflector.registerType(rc.DefaultCompiler, {
-    "factory": (parser, shadowDomStrategy, templateLoader) =>
-      new rc.DefaultCompiler(parser, shadowDomStrategy, templateLoader),
-    "parameters": [[Parser], [ShadowDomStrategy], [TemplateLoader]],
-    "annotations": []
-  });
-
-  reflector.registerType(rvf.ViewFactory, {
-    "factory": (capacity, eventManager, shadowDomStrategy) =>
-      new rvf.ViewFactory(capacity, eventManager, shadowDomStrategy),
-    "parameters": [[new Inject(rvf.VIEW_POOL_CAPACITY)], [EventManager], [ShadowDomStrategy]],
-    "annotations": []
-  });
-
-  reflector.registerType(rvf.VIEW_POOL_CAPACITY, {
-    "factory": () => 100000,
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(ProtoViewFactory, {
-    "factory": (changeDetection, renderer) =>
-      new ProtoViewFactory(changeDetection, renderer),
-    "parameters": [[ChangeDetection], [Renderer]],
-    "annotations": []
-  });
-
-  reflector.registerType(ViewFactory, {
-    "factory": (capacity) =>
-      new ViewFactory(capacity),
-    "parameters": [[new Inject(VIEW_POOL_CAPACITY)]],
-    "annotations": []
-  });
-
-  reflector.registerType(VIEW_POOL_CAPACITY, {
-    "factory": () => 100000,
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerGetters({
-    'value': (a) => a.value,
-    'left': (a) => a.left,
-    'right': (a) => a.right,
-    'initData': (a) => a.initData,
-    'data': (a) => a.data,
-    'condition': (a) => a.condition,
-  });
-
-  reflector.registerSetters({
-    'value': (a,v) => a.value = v,
-    'left': (a,v) => a.left = v,
-    'right': (a,v) => a.right = v,
-    'initData': (a,v) => a.initData = v,
-    'data': (a,v) => a.data = v,
-    'condition': (a,v) => a.condition = v,
-    'if': (a,v) => a['if'] = v,
-  });
+  reflector.reflectionCapabilities = new ReflectionCapabilities();
 }
 
 var BASELINE_TREE_TEMPLATE;
@@ -346,7 +116,7 @@ export function main() {
   function noop() {}
 
   function initNg2() {
-    bootstrap(AppComponent).then((injector) => {
+    bootstrap(AppComponent, createBindings()).then((injector) => {
       lifeCycle = injector.get(LifeCycle);
 
       app = injector.get(AppComponent);
@@ -475,6 +245,11 @@ class BaseLineIf {
   }
 }
 
+@Component({selector: 'app'})
+@View({
+  directives: [TreeComponent],
+  template: `<tree [data]='initData'></tree>`
+})
 class AppComponent {
   initData:TreeNode;
   constructor() {
@@ -484,6 +259,14 @@ class AppComponent {
   }
 }
 
+@Component({
+  selector: 'tree',
+  properties: {'data': 'data'}
+})
+@View({
+  directives: [TreeComponent, If],
+  template: `<span> {{data.value}} <span template='if data.right != null'><tree [data]='data.right'></tree></span><span template='if data.left != null'><tree [data]='data.left'></tree></span></span>`
+})
 class TreeComponent {
   data:TreeNode;
 }