perf(view): use pre-resolved bindings for child injector init

Creating a child injector from pre-resolved bindings (if any) is an
order of magnitude faster.

modules/angular2/test/core/compiler/directive_metadata_reader_spec.js

@@ -1,13 +1,18 @@
+import {isPresent} from 'angular2/src/facade/lang';
+import {ListWrapper} from 'angular2/src/facade/collection';
 import {ddescribe, describe, it, iit, expect, beforeEach} from 'angular2/test_lib';
 import {DirectiveMetadataReader} from 'angular2/src/core/compiler/directive_metadata_reader';
 import {Decorator, Component, Viewport} from 'angular2/src/core/annotations/annotations';
 import {DirectiveMetadata} from 'angular2/src/core/compiler/directive_metadata';
+import {Injectable, Injector} from 'angular2/di';
 
+@Injectable()
+class SomeInjectable {}
 
 @Decorator({selector: 'someDecorator'})
 class SomeDecorator {}
 
-@Component({selector: 'someComponent'})
+@Component({selector: 'someComponent', injectables: [SomeInjectable]})
 class SomeComponent {}
 
 @Viewport({selector: 'someViewport'})
@@ -27,19 +32,30 @@ export function main() {
     it('should read out the Decorator annotation', () => {
       var directiveMetadata = reader.read(SomeDecorator);
       expect(directiveMetadata).toEqual(
-        new DirectiveMetadata(SomeDecorator, new Decorator({selector: 'someDecorator'})));
+        new DirectiveMetadata(SomeDecorator, new Decorator({selector: 'someDecorator'}), null));
     });
 
     it('should read out the Viewport annotation', () => {
       var directiveMetadata = reader.read(SomeViewport);
       expect(directiveMetadata).toEqual(
-        new DirectiveMetadata(SomeViewport, new Viewport({selector: 'someViewport'})));
+        new DirectiveMetadata(SomeViewport, new Viewport({selector: 'someViewport'}), null));
     });
 
     it('should read out the Component annotation', () => {
-      var directiveMetadata = reader.read(SomeComponent);
-      expect(directiveMetadata).toEqual(
-        new DirectiveMetadata(SomeComponent, new Component({selector: 'someComponent'})));
+      var m = reader.read(SomeComponent);
+      // For some reason `toEqual` fails to compare ResolvedBinding objects.
+      // Have to decompose and compare.
+      expect(m.type).toEqual(SomeComponent);
+      expect(m.annotation)
+          .toEqual(new Component({selector: 'someComponent', injectables: [SomeInjectable]}));
+      var resolvedList = ListWrapper.reduce(m.resolvedInjectables, function(prev, elem) {
+        if (isPresent(elem)) {
+          ListWrapper.push(prev, elem);
+        }
+        return prev;
+      }, []);
+      expect(resolvedList.length).toBe(1);
+      expect(resolvedList[0].key.token).toBe(SomeInjectable);
     });
 
     it('should throw if not matching annotation is found', () => {

modules/angular2/test/di/injector_spec.js

@@ -1,5 +1,6 @@
+import {isBlank} from 'angular2/src/facade/lang';
 import {describe, ddescribe, it, iit, expect, beforeEach} from 'angular2/test_lib';
-import {Injector, Inject, InjectLazy, Optional, bind} from 'angular2/di';
+import {Injector, Inject, InjectLazy, Optional, bind, ResolvedBinding} from 'angular2/di';
 
 class Engine {
 }
@@ -364,5 +365,15 @@ export function main() {
         expect(e1).toBe(e2);
       });
     });
+
+    describe('resolve', function() {
+      it('should resolve and flatten', function() {
+        var bindings = Injector.resolve([Engine, [BrokenEngine]]);
+        bindings.forEach(function(b) {
+          if (isBlank(b)) return;  // the result is a sparse array
+          expect(b instanceof ResolvedBinding).toBe(true);
+        });
+      });
+    });
   });
 }