feat(di): removed app injector

BREAKING CHANGE:

THe appInjector property has been removed. Instead use viewInjector or hostInjector.

Author: vsavkin

modules/angular2/di.ts

@@ -36,9 +36,7 @@ export {
   PUBLIC_AND_PRIVATE,
   PUBLIC,
   PRIVATE,
-  undefinedValue,
-  InjectorInlineStrategy,
-  InjectorDynamicStrategy
+  undefinedValue
 } from './src/di/injector';
 export {Binding, BindingBuilder, ResolvedBinding, Dependency, bind} from './src/di/binding';
 export {Key, KeyRegistry, TypeLiteral} from './src/di/key';

modules/angular2/docs/core/02_directives.md

@@ -216,7 +216,7 @@ To better understand the kinds of injections which are supported in Angular we h
 
 ### Injecting Services
 
-Service injection is the most straight forward kind of injection which Angular supports. It involves a component configuring the `appInjector` and then letting the directive ask for the configured service.
+Service injection is the most straight forward kind of injection which Angular supports. It involves a component configuring the `viewInjector` or `hostInjector` and then letting the directive ask for the configured service.
 
 This example illustrates how to inject `MyService` into `House` directive.
 
@@ -227,7 +227,7 @@ class MyService {}                   | Assume a service which needs to be inject
                                      |
 @Component({                         | Assume a top level application component which
   selector: 'my-app',                | configures the services to be injected.
-  appInjector: [MyService]           |
+  viewInjector: [MyService]           |
 })                                   |
 @View({                              | Assume we have a template that needs to be
   templateUrl: 'my_app.html',        | configured with directives to be injected.
@@ -329,8 +329,7 @@ Shadow DOM provides an encapsulation for components, so as a general rule it doe
 
 ```
 @Component({
-  selector: '[kid]',
-  appInjector: []
+  selector: '[kid]'
 })
 @View({
   templateUrl: 'kid.html',
@@ -348,8 +347,7 @@ class Kid {
 }
 
 @Component({
-  selector: '[dad]',
-  appInjector: [Grandpa]
+  selector: '[dad]'
 })
 @View({
   templateUrl: 'dad.html',
@@ -364,7 +362,7 @@ class Dad {
 
 @Component({
   selector: '[grandpa]',
-  appInjector: []
+  viewInjector: []
 })
 @View({
   templateUrl: 'grandpa.html',

modules/angular2/http.ts

@@ -48,7 +48,7 @@ export {URLSearchParams} from 'angular2/src/http/url_search_params';
  *
  * ```
  * import {httpInjectables, Http} from 'angular2/http';
- * @Component({selector: 'http-app', appInjector: [httpInjectables]})
+ * @Component({selector: 'http-app', viewInjector: [httpInjectables]})
  * @View({template: '{{data}}'})
  * class MyApp {
  *   constructor(http:Http) {

modules/angular2/src/core/annotations_impl/annotations.ts

@@ -822,8 +822,7 @@ export interface DirectiveArgs {
  * When a component is instantiated, Angular
  * - creates a shadow DOM for the component.
  * - loads the selected template into the shadow DOM.
- * - creates a child {@link Injector} which is configured with the `appInjector` for the
- * {@link Component}.
+ * - creates all the injectable objects configured with `hostInjector` and `viewInjector`.
  *
  * All template expressions and statements are then evaluated against the component instance.
  *
@@ -865,59 +864,6 @@ export class Component extends Directive {
    */
   changeDetection: string;
 
-  /**
-   * Defines the set of injectable objects that are visible to a Component and its children.
-   *
-   * The `appInjector` defined in the Component annotation allow you to configure a set of bindings
-   * for the component's
-   * injector.
-   *
-   * When a component is instantiated, Angular creates a new child Injector, which is configured
-   * with the bindings in
-   * the Component `appInjector` annotation. The injectable objects then become available for
-   * injection to the component
-   * itself and any of the directives in the component's template, i.e. they are not available to
-   * the directives which
-   * are children in the component's light DOM.
-   *
-   *
-   * The syntax for configuring the `appInjector` injectable is identical to {@link Injector}
-   * injectable configuration.
-   * See {@link Injector} for additional detail.
-   *
-   *
-   * ## Simple Example
-   *
-   * Here is an example of a class that can be injected:
-   *
-   * ```
-   * class Greeter {
-   *    greet(name:string) {
-   *      return 'Hello ' + name + '!';
-   *    }
-   * }
-   *
-   * @Component({
-   *   selector: 'greet',
-   *   appInjector: [
-   *     Greeter
-   *   ]
-   * })
-   * @View({
-   *   template: `{{greeter.greet('world')}}!`,
-   *   directives: [Child]
-   * })
-   * class HelloWorld {
-   *   greeter:Greeter;
-   *
-   *   constructor(greeter:Greeter) {
-   *     this.greeter = greeter;
-   *   }
-   * }
-   * ```
-   */
-  appInjector: List<any>;
-
   /**
    * Defines the set of injectable objects that are visible to its view dom children.
    *
@@ -960,9 +906,8 @@ export class Component extends Directive {
    */
   viewInjector: List<any>;
 
-  constructor({selector, properties, events, host, exportAs, appInjector, lifecycle, hostInjector,
-               viewInjector, changeDetection = DEFAULT,
-               compileChildren = true}: ComponentArgs = {}) {
+  constructor({selector, properties, events, host, exportAs, lifecycle, hostInjector, viewInjector,
+               changeDetection = DEFAULT, compileChildren = true}: ComponentArgs = {}) {
     super({
       selector: selector,
       properties: properties,
@@ -975,13 +920,11 @@ export class Component extends Directive {
     });
 
     this.changeDetection = changeDetection;
-    this.appInjector = appInjector;
     this.viewInjector = viewInjector;
   }
 }
 
 export interface ComponentArgs extends DirectiveArgs {
-  appInjector?: List<any>;
   viewInjector?: List<any>;
   changeDetection?: string;
 }

modules/angular2/src/core/application.ts

@@ -209,11 +209,9 @@ function _createNgZone(givenReporter: Function): NgZone {
  *  1. It uses the component's `selector` property to locate the DOM element which needs to be
  * upgraded into
  *     the angular component.
- *  2. It creates a new child injector (from the platform injector) and configures the injector with
- * the component's
- *     `appInjector`. Optionally, you can also override the injector configuration for an app by
- * invoking
- *     `bootstrap` with the `componentInjectableBindings` argument.
+ *  2. It creates a new child injector (from the platform injector). Optionally, you can also
+ * override the injector configuration for an app by
+ * invoking `bootstrap` with the `componentInjectableBindings` argument.
  *  3. It creates a new `Zone` and connects it to the angular application's change detection domain
  * instance.
  *  4. It creates a shadow DOM on the selected component's host element and loads the template into
@@ -270,9 +268,9 @@ function _createNgZone(givenReporter: Function): NgZone {
  * - `appComponentType`: The root component which should act as the application. This is a reference
  * to a `Type`
  *   which is annotated with `@Component(...)`.
- * - `componentInjectableBindings`: An additional set of bindings that can be added to `appInjector`
- * for the
- * {@link Component} to override default injection behavior.
+ * - `componentInjectableBindings`: An additional set of bindings that can be added to the app
+ * injector
+ * to override default injection behavior.
  * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
  * unhandled exceptions.
  *

modules/angular2/src/core/compiler/dynamic_component_loader.ts

@@ -30,8 +30,8 @@ export class DynamicComponentLoader {
    * component's selector.
    * The loaded component receives injection normally as a hosted view.
    */
-  loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string = null,
-             injector: Injector = null): Promise<ComponentRef> {
+  loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string,
+             injector: Injector): Promise<ComponentRef> {
     return this._compiler.compileInHost(typeOrBinding)
         .then(hostProtoViewRef => {
           var hostViewRef =
@@ -51,23 +51,23 @@ export class DynamicComponentLoader {
    * injection normally as a hosted view.
    */
   loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string,
-                   injector: Injector = null): Promise<ComponentRef> {
+                   bindings: ResolvedBinding[] = null): Promise<ComponentRef> {
     return this.loadNextToLocation(
         typeOrBinding, this._viewManager.getNamedElementInComponentView(hostLocation, anchorName),
-        injector);
+        bindings);
   }
 
   /**
    * Loads a component next to the provided ElementRef. The loaded component receives
    * injection normally as a hosted view.
    */
   loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef,
-                     injector: Injector = null): Promise<ComponentRef> {
+                     bindings: ResolvedBinding[] = null): Promise<ComponentRef> {
     return this._compiler.compileInHost(typeOrBinding)
         .then(hostProtoViewRef => {
           var viewContainer = this._viewManager.getViewContainer(location);
           var hostViewRef =
-              viewContainer.create(hostProtoViewRef, viewContainer.length, null, injector);
+              viewContainer.create(hostProtoViewRef, viewContainer.length, null, bindings);
           var newLocation = this._viewManager.getHostElement(hostViewRef);
           var component = this._viewManager.getComponent(newLocation);