feat(core): Create StaticInjector which does not depend on Reflect po…

…lyfill.

packages/core/src/di.ts

@@ -18,7 +18,8 @@ export {forwardRef, resolveForwardRef, ForwardRefFn} from './di/forward_ref';
 
 export {Injector} from './di/injector';
 export {ReflectiveInjector} from './di/reflective_injector';
-export {Provider, TypeProvider, ValueProvider, ClassProvider, ExistingProvider, FactoryProvider} from './di/provider';
+export {StaticProvider, ValueProvider, ExistingProvider, FactoryProvider} from './di/provider';
+export {Provider, TypeProvider, ClassProvider} from './di/reflective_provider_interfaces';
 export {ResolvedReflectiveFactory, ResolvedReflectiveProvider} from './di/reflective_provider';
 export {ReflectiveKey} from './di/reflective_key';
 export {InjectionToken, OpaqueToken} from './di/injection_token';

packages/core/src/di/injector.ts

@@ -10,6 +10,8 @@ import {Type} from '../type';
 import {stringify} from '../util';
 
 import {InjectionToken} from './injection_token';
+import {StaticProvider} from './provider';
+import {StaticInjector} from './static_injector';
 
 const _THROW_IF_NOT_FOUND = new Object();
 export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
@@ -60,4 +62,8 @@ export abstract class Injector {
    * @suppress {duplicate}
    */
   abstract get(token: any, notFoundValue?: any): any;
+
+  static create(providers: StaticProvider[], parent?: Injector): Injector {
+    return new StaticInjector(providers, parent);
+  }
 }

packages/core/src/di/provider.ts

@@ -9,57 +9,83 @@
 import {Type} from '../type';
 
 /**
- * @whatItDoes Configures the {@link Injector} to return an instance of `Type` when `Type' is used
- * as token.
+ * @whatItDoes Configures the {@link Injector} to return a value for a token.
  * @howToUse
  * ```
- * @Injectable()
- * class MyService {}
- *
- * const provider: TypeProvider = MyService;
+ * const provider: ValueProvider = {provide: 'someToken', useValue: 'someValue'};
  * ```
  *
  * @description
- *
- * Create an instance by invoking the `new` operator and supplying additional arguments.
- * This form is a short form of `TypeProvider`;
- *
  * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
  *
  * ### Example
  *
- * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
+ * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
  *
  * @stable
  */
-export interface TypeProvider extends Type<any> {}
+export interface ValueProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * The value to inject.
+   */
+  useValue: any;
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
 
 /**
- * @whatItDoes Configures the {@link Injector} to return a value for a token.
+ * @whatItDoes Configures the {@link Injector} to return an instance of `useClass` for a token.
  * @howToUse
  * ```
- * const provider: ValueProvider = {provide: 'someToken', useValue: 'someValue'};
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: ClassProvider = {provide: 'someToken', useClass: MyService};
  * ```
  *
  * @description
  * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
  *
  * ### Example
  *
- * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
  *
  * @stable
  */
-export interface ValueProvider {
+export interface StaticClassProvider {
   /**
    * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
    */
   provide: any;
 
   /**
-   * The value to inject.
+   * An optional class to instantiate for the `token`. (If not provided `provide` is assumed to be a
+   * class to
+   * instantiate)
    */
-  useValue: any;
+  useClass: Type<any>;
+
+  /**
+   * A list of `token`s which need to be resolved by the injector. The list of values is then
+   * used as arguments to the `useClass` constructor.
+   */
+  deps: any[];
 
   /**
    * If true, then injector returns an array of instances. This is useful to allow multiple
@@ -87,23 +113,24 @@ export interface ValueProvider {
  *
  * ### Example
  *
- * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
  *
  * Note that following two providers are not equal:
  * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
  *
  * @stable
  */
-export interface ClassProvider {
+export interface ConstructorProvider {
   /**
    * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
    */
-  provide: any;
+  provide: Type<any>;
 
   /**
-   * Class to instantiate for the `token`.
+   * A list of `token`s which need to be resolved by the injector. The list of values is then
+   * used as arguments to the `useClass` constructor.
    */
-  useClass: Type<any>;
+  deps: any[];
 
   /**
    * If true, then injector returns an array of instances. This is useful to allow multiple
@@ -206,15 +233,15 @@ export interface FactoryProvider {
 }
 
 /**
- * @whatItDoes Describes how the {@link Injector} should be configured.
+ * @whatItDoes Describes how the {@link Injector} should be configured in a static way (Without
+ * reflection).
  * @howToUse
- * See {@link TypeProvider}, {@link ValueProvider}, {@link ClassProvider}, {@link ExistingProvider},
- * {@link FactoryProvider}.
+ * See {@link ValueProvider}, {@link ExistingProvider}, {@link FactoryProvider}.
  *
  * @description
  * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
  *
  * @stable
  */
-export type Provider =
-    TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];
+export type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider |
+    ConstructorProvider | FactoryProvider | any[];

packages/core/src/di/reflective_injector.ts

@@ -8,10 +8,11 @@
 
 import {Injector, THROW_IF_NOT_FOUND} from './injector';
 import {Self, SkipSelf} from './metadata';
-import {Provider} from './provider';
 import {cyclicDependencyError, instantiationError, noProviderError, outOfBoundsError} from './reflective_errors';
 import {ReflectiveKey} from './reflective_key';
 import {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';
+import {Provider} from './reflective_provider_interfaces';
+
 
 // Threshold for the dynamic version
 const UNDEFINED = new Object();

packages/core/src/di/reflective_provider.ts

@@ -12,9 +12,10 @@ import {Type} from '../type';
 import {resolveForwardRef} from './forward_ref';
 import {InjectionToken} from './injection_token';
 import {Inject, Optional, Self, SkipSelf} from './metadata';
-import {ClassProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ValueProvider} from './provider';
+import {ExistingProvider, FactoryProvider, ValueProvider} from './provider';
 import {invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError} from './reflective_errors';
 import {ReflectiveKey} from './reflective_key';
+import {ClassProvider, Provider, TypeProvider} from './reflective_provider_interfaces';
 
 
 interface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider, ExistingProvider,

packages/core/src/di/reflective_provider_interfaces.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from '../type';
+import {ValueProvider, ExistingProvider, FactoryProvider} from './provider';
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of `Type` when `Type' is used
+ * as token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: TypeProvider = MyService;
+ * ```
+ *
+ * @description
+ *
+ * Create an instance by invoking the `new` operator and supplying additional arguments.
+ * This form is a short form of `TypeProvider`;
+ *
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
+ *
+ * @stable
+ */
+export interface TypeProvider extends Type<any> {}
+
+/**
+ * @whatItDoes Configures the {@link Injector} to return an instance of `useClass` for a token.
+ * @howToUse
+ * ```
+ * @Injectable()
+ * class MyService {}
+ *
+ * const provider: ClassProvider = {provide: 'someToken', useClass: MyService};
+ * ```
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
+ *
+ * @stable
+ */
+export interface ClassProvider {
+  /**
+   * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+   */
+  provide: any;
+
+  /**
+   * Class to instantiate for the `token`.
+   */
+  useClass: Type<any>;
+
+  /**
+   * If true, then injector returns an array of instances. This is useful to allow multiple
+   * providers spread across many files to provide configuration information to a common token.
+   *
+   * ### Example
+   *
+   * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+   */
+  multi?: boolean;
+}
+
+/**
+ * @whatItDoes Describes how the {@link Injector} should be configured.
+ * @howToUse
+ * See {@link TypeProvider}, {@link ClassProvider}, {@link StaticProvider}.
+ *
+ * @description
+ * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
+ *
+ * @stable
+ */
+export type Provider = TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];