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/largetable/largetable_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, BaseException} from 'angular2/src/facade/lang';
 import {window, document, gc} from 'angular2/src/facade/browser';
@@ -42,349 +43,34 @@ 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';
+
+export const BENCHMARK_TYPE = 'LargetableComponent.benchmarkType';
+export const LARGETABLE_ROWS = 'LargetableComponent.rows';
+export const LARGETABLE_COLS = 'LargetableComponent.cols';
+function _createBindings() {
+  return [
+    bind(BENCHMARK_TYPE).toValue(getStringParameter('benchmarkType')),
+    bind(LARGETABLE_ROWS).toValue(getIntParameter('rows')),
+    bind(LARGETABLE_COLS).toValue(getIntParameter('columns'))
+  ];
+}
 
 var BASELINE_LARGETABLE_TEMPLATE;
 
 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: [LargetableComponent],
-            template: `<largetable [data]='data' [benchmarkType]='benchmarkType'></largetable>`
-        })]
-  });
-
-  reflector.registerType(LargetableComponent, {
-    'factory': () => new LargetableComponent(getStringParameter('benchmarkType'),
-        getIntParameter('rows'), getIntParameter('columns')),
-    'parameters': [],
-    'annotations': [
-        new Component({
-            selector: 'largetable',
-            properties: {
-                'data': 'data',
-                'benchmarkType': 'benchmarktype'
-              }
-        }),
-        new View({
-            directives: [For, Switch, SwitchWhen, SwitchDefault],
-            template: `
-                <table [switch]="benchmarkType">
-                  <tbody template="switch-when 'interpolation'">
-                    <tr template="for #row of data">
-                      <td template="for #column of row">
-                        {{column.i}}:{{column.j}}|
-                      </td>
-                    </tr>
-                  </tbody>
-                  <tbody template="switch-when 'interpolationAttr'">
-                    <tr template="for #row of data">
-                      <td template="for #column of row" i="{{column.i}}" j="{{column.j}}">
-                        i,j attrs
-                      </td>
-                    </tr>
-                  </tbody>
-                  <tbody template="switch-when 'interpolationFn'">
-                    <tr template="for #row of data">
-                      <td template="for #column of row">
-                        {{column.iFn()}}:{{column.jFn()}}|
-                      </td>
-                    </tr>
-                  </tbody>
-                  <tbody template="switch-default">
-                    <tr>
-                      <td>
-                        <em>{{benchmarkType}} not yet implemented</em>
-                      </td>
-                    </tr>
-                  </tbody>
-                </table>`
-        })
-    ]
-  });
-
-  reflector.registerType(If, {
-    'factory': (vp) => new If(vp),
-    'parameters': [[ViewContainer]],
-    'annotations' : [new Viewport({
-      selector: '[if]',
-      properties: {
-        'condition': 'if'
-      }
-    })]
-  });
-
-  reflector.registerType(For, {
-    'factory': (vp) => new For(vp),
-    'parameters': [[ViewContainer]],
-    'annotations' : [new Viewport({
-      selector: '[for]',
-      properties: {
-        'iterableChanges': 'of | iterableDiff'
-      }
-    })]
-  });
-
-  reflector.registerType(Switch, {
-    'factory': () => new Switch(),
-    'parameters': [],
-    'annotations' : [new Decorator({
-      selector: '[switch]',
-      properties: {
-        'value': 'switch'
-      }
-    })]
-  });
-
-  reflector.registerType(SwitchWhen, {
-    'factory': (vc, ss) => new SwitchWhen(vc, ss),
-    'parameters': [[ViewContainer],[Switch, new Parent()]],
-    'annotations' : [new Viewport({
-        selector: '[switch-when]',
-        properties: {
-          'when': 'switch-when'
-        }
-      })]
-  });
-
-  reflector.registerType(SwitchDefault, {
-    'factory': (vc, ss) => new SwitchDefault(vc, ss),
-    'parameters': [[ViewContainer],[Switch, new Parent()]],
-    'annotations' : [new Viewport({
-        selector: '[switch-default]'
-      })]
-  });
-
-  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(StyleUrlResolver, {
-    "factory": (urlResolver) => new StyleUrlResolver(urlResolver),
-    "parameters": [[UrlResolver]],
-    "annotations": []
-  });
-
-  reflector.registerType(TestabilityRegistry, {
-    "factory": () => new TestabilityRegistry(),
-    "parameters": [],
-    "annotations": []
-  });
-
-  reflector.registerType(Testability, {
-    "factory": () => new Testability(),
-    "parameters": [],
-    "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.reflectionCapabilities = new ReflectionCapabilities();
 
+  // TODO(kegluneq): Generate these.
   reflector.registerGetters({
-    'data': (a) => a.data,
-    'benchmarkType': (a) => a.benchmarkType,
-    'benchmarktype': (a) => a.benchmarktype,
-    'when': (a) => a.when,
-    'switchWhen': (a) => a.switchWhen,
-    'switchwhen': (a) => a.switchwhen,
-    'value': (a) => a.value,
-    'iterable': (a) => a.iterable,
-    'iterableChanges': (a) => a.iterableChanges,
-    'row': (a) => a.row,
-    'column': (a) => a.column,
-    'i': (a) => a.i,
-    'j': (a) => a.j,
-    'switch': (a) => {throw new BaseException('not implemented, reserved word in dart')},
-    'for': (a) => {throw new BaseException('not implemented, reserved word in dart')},
-    'of': (a) => a.of
+    'benchmarktype': (o) => o.benchmarktype,
+    'switch': (o) => null,
+    'switchWhen': (o) => o.switchWhen
   });
-
-  reflector.registerMethods({
-    'iFn': (a, args) => a.iFn(),
-    'jFn': (a, args) => a.jFn(),
-  })
-
   reflector.registerSetters({
-    'data': (a,v) => a.data = v,
-    'benchmarkType': (a,v) => a.benchmarkType = v,
-    'benchmarktype': (a,v) => a.benchmarktype = v,
-    'when': (a,v) => a.when = v,
-    'switchWhen': (a,v) => a.switchWhen = v,
-    'switchwhen': (a,v) => a.switchwhen = v,
-    'value': (a,v) => a.value = v,
-    'iterable': (a,v) => a.iterable = v,
-    'iterableChanges': (a,v) => a.iterableChanges = v,
-    'row': (a,v) => a.row = v,
-    'column': (a,v) => a.column = v,
-    'i': (a,v) => a.i = v,
-    'j': (a,v) => a.j = v,
-    'switch': (a,v) => {throw new BaseException('not implemented, reserved word in dart')},
-    'for': (a,v) => {throw new BaseException('not implemented, reserved word in dart')},
-    'of': (a,v) => a.j = v
+    'benchmarktype': (o, v) => o.benchmarktype = v,
+    'switch': (o, v) => null,
+    'switchWhen': (o, v) => o.switchWhen = v
   });
 }
 
@@ -456,7 +142,7 @@ export function main() {
   function noop() {}
 
   function initNg2() {
-    bootstrap(AppComponent).then((injector) => {
+    bootstrap(AppComponent, _createBindings()).then((injector) => {
       app = injector.get(AppComponent);
       lifecycle = injector.get(LifeCycle);
       bindAction('#ng2DestroyDom', ng2DestroyDom);
@@ -556,17 +242,68 @@ class CellData {
   }
 }
 
+@Component({
+  selector: 'app'
+})
+@View({
+  directives: [LargetableComponent],
+  template: `<largetable [data]='data' [benchmarkType]='benchmarkType'></largetable>`
+})
 class AppComponent {
   data;
   benchmarkType:string;
 }
 
+@Component({
+  selector: 'largetable',
+  properties: {
+      'data': 'data',
+      'benchmarkType': 'benchmarktype'
+  }
+})
+@View({
+  directives: [For, Switch, SwitchWhen, SwitchDefault],
+  template: `
+      <table [switch]="benchmarkType">
+        <tbody template="switch-when 'interpolation'">
+          <tr template="for #row of data">
+            <td template="for #column of row">
+              {{column.i}}:{{column.j}}|
+            </td>
+          </tr>
+        </tbody>
+        <tbody template="switch-when 'interpolationAttr'">
+          <tr template="for #row of data">
+            <td template="for #column of row" i="{{column.i}}" j="{{column.j}}">
+              i,j attrs
+            </td>
+          </tr>
+        </tbody>
+        <tbody template="switch-when 'interpolationFn'">
+          <tr template="for #row of data">
+            <td template="for #column of row">
+              {{column.iFn()}}:{{column.jFn()}}|
+            </td>
+          </tr>
+        </tbody>
+        <tbody template="switch-default">
+          <tr>
+            <td>
+              <em>{{benchmarkType}} not yet implemented</em>
+            </td>
+          </tr>
+        </tbody>
+      </table>`
+})
 class LargetableComponent {
   data;
   benchmarkType:string;
   rows:number;
   columns:number;
-  constructor(benchmarkType:string,rows:number,columns:number) {
+  constructor(
+      @Inject(BENCHMARK_TYPE) benchmarkType,
+      @Inject(LARGETABLE_ROWS) rows,
+      @Inject(LARGETABLE_COLS) columns) {
     this.benchmarkType = benchmarkType;
     this.rows = rows;
     this.columns = columns;