refactor(Type): merge Type and ConcreType<?> into Type<?> (#10616)

Closes #9729

BREAKING CHANGE:

`Type` is now `Type<T>` which means that in most cases you have to
use `Type<any>` in place of `Type`.

We don't expect that any user applications use the `Type` type.

modules/@angular/core/src/di/forward_ref.ts

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Type, isFunction, stringify} from '../facade/lang';
+import {isFunction, stringify} from '../facade/lang';
+import {Type} from '../type';
 
 
 /**
@@ -31,10 +32,10 @@ export interface ForwardRefFn { (): any; }
  * {@example core/di/ts/forward_ref/forward_ref.ts region='forward_ref'}
  * @experimental
  */
-export function forwardRef(forwardRefFn: ForwardRefFn): Type {
+export function forwardRef(forwardRefFn: ForwardRefFn): Type<any> {
   (<any>forwardRefFn).__forward_ref__ = forwardRef;
   (<any>forwardRefFn).toString = function() { return stringify(this()); };
-  return (<Type><any>forwardRefFn);
+  return (<Type<any>><any>forwardRefFn);
 }
 
 /**

modules/@angular/core/src/di/provider.ts

@@ -7,7 +7,8 @@
  */
 
 import {BaseException} from '../facade/exceptions';
-import {Type, isBlank, isFunction, isType, normalizeBool, stringify} from '../facade/lang';
+import {isBlank, isFunction, isType, normalizeBool, stringify} from '../facade/lang';
+import {Type} from '../type';
 
 
 /**
@@ -61,7 +62,7 @@ export class Provider {
    * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
    * ```
    */
-  useClass: Type;
+  useClass: Type<any>;
 
   /**
    * Binds a DI token to a value.
@@ -157,7 +158,7 @@ export class Provider {
   _multi: boolean;
 
   constructor(token: any, {useClass, useValue, useExisting, useFactory, deps, multi}: {
-    useClass?: Type,
+    useClass?: Type<any>,
     useValue?: any,
     useExisting?: any,
     useFactory?: Function,
@@ -213,7 +214,7 @@ export class Provider {
  */
 export class Binding extends Provider {
   constructor(token: any, {toClass, toValue, toAlias, toFactory, deps, multi}: {
-    toClass?: Type,
+    toClass?: Type<any>,
     toValue?: any,
     toAlias?: any,
     toFactory: Function, deps?: Object[], multi?: boolean
@@ -301,7 +302,7 @@ export class ProviderBuilder {
    * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
    * ```
    */
-  toClass(type: Type): Provider {
+  toClass(type: Type<any>): Provider {
     if (!isType(type)) {
       throw new BaseException(
           `Trying to create a class provider but "${stringify(type)}" is not a class!`);
@@ -396,7 +397,7 @@ export class ProviderBuilder {
  * @deprecated
  */
 export function provide(token: any, {useClass, useValue, useExisting, useFactory, deps, multi}: {
-  useClass?: Type,
+  useClass?: Type<any>,
   useValue?: any,
   useExisting?: any,
   useFactory?: Function,

modules/@angular/core/src/di/reflective_exceptions.ts

@@ -8,7 +8,8 @@
 
 import {ListWrapper} from '../facade/collection';
 import {BaseException, WrappedException} from '../facade/exceptions';
-import {Type, isBlank, stringify} from '../facade/lang';
+import {isBlank, stringify} from '../facade/lang';
+import {Type} from '../type';
 
 import {Provider} from './provider';
 import {ReflectiveInjector} from './reflective_injector';
@@ -225,11 +226,11 @@ export class InvalidProviderError extends BaseException {
  * @stable
  */
 export class NoAnnotationError extends BaseException {
-  constructor(typeOrFunc: Type|Function, params: any[][]) {
+  constructor(typeOrFunc: Type<any>|Function, params: any[][]) {
     super(NoAnnotationError._genMessage(typeOrFunc, params));
   }
 
-  private static _genMessage(typeOrFunc: Type|Function, params: any[][]) {
+  private static _genMessage(typeOrFunc: Type<any>|Function, params: any[][]) {
     var signature: string[] = [];
     for (var i = 0, ii = params.length; i < ii; i++) {
       var parameter = params[i];

modules/@angular/core/src/di/reflective_injector.ts

@@ -8,7 +8,7 @@
 
 import {ListWrapper} from '../facade/collection';
 import {BaseException, unimplemented} from '../facade/exceptions';
-import {Type} from '../facade/lang';
+import {Type} from '../type';
 
 import {Injector, THROW_IF_NOT_FOUND} from './injector';
 import {SelfMetadata, SkipSelfMetadata} from './metadata';
@@ -17,7 +17,7 @@ import {AbstractProviderError, CyclicDependencyError, InstantiationError, NoProv
 import {ReflectiveKey} from './reflective_key';
 import {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';
 
-var __unused: Type;  // avoid unused import when Type union types are erased
+var __unused: Type<any>;  // avoid unused import when Type union types are erased
 
 // Threshold for the dynamic version
 const _MAX_CONSTRUCTION_COUNTER = 10;
@@ -392,7 +392,7 @@ export abstract class ReflectiveInjector implements Injector {
    *
    * See {@link ReflectiveInjector#fromResolvedProviders} for more info.
    */
-  static resolve(providers: Array<Type|Provider|{[k: string]: any}|any[]>):
+  static resolve(providers: Array<Type<any>|Provider|{[k: string]: any}|any[]>):
       ResolvedReflectiveProvider[] {
     return resolveReflectiveProviders(providers);
   }
@@ -424,7 +424,7 @@ export abstract class ReflectiveInjector implements Injector {
    * See {@link Injector#resolve} and {@link Injector#fromResolvedProviders}.
    */
   static resolveAndCreate(
-      providers: Array<Type|Provider|{[k: string]: any}|any[]>,
+      providers: Array<Type<any>|Provider|{[k: string]: any}|any[]>,
       parent: Injector = null): ReflectiveInjector {
     var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
     return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
@@ -516,7 +516,7 @@ export abstract class ReflectiveInjector implements Injector {
    * because it needs to resolve the passed-in providers first.
    * See {@link Injector#resolve} and {@link Injector#createChildFromResolved}.
    */
-  resolveAndCreateChild(providers: Array<Type|Provider|{[k: string]: any}|any[]>):
+  resolveAndCreateChild(providers: Array<Type<any>|Provider|{[k: string]: any}|any[]>):
       ReflectiveInjector {
     return unimplemented();
   }
@@ -574,7 +574,7 @@ export abstract class ReflectiveInjector implements Injector {
    * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
    * ```
    */
-  resolveAndInstantiate(provider: Type|Provider): any { return unimplemented(); }
+  resolveAndInstantiate(provider: Type<any>|Provider): any { return unimplemented(); }
 
   /**
    * Instantiates an object using a resolved provider in the context of the injector.
@@ -644,7 +644,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
    */
   get internalStrategy(): any { return this._strategy; }
 
-  resolveAndCreateChild(providers: Array<Type|Provider|any[]>): ReflectiveInjector {
+  resolveAndCreateChild(providers: Array<Type<any>|Provider|any[]>): ReflectiveInjector {
     var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
     return this.createChildFromResolved(ResolvedReflectiveProviders);
   }
@@ -656,7 +656,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
     return inj;
   }
 
-  resolveAndInstantiate(provider: Type|Provider): any {
+  resolveAndInstantiate(provider: Type<any>|Provider): any {
     return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
   }
 

modules/@angular/core/src/di/reflective_provider.ts

@@ -7,8 +7,9 @@
  */
 
 import {ListWrapper, MapWrapper} from '../facade/collection';
-import {Type, isArray, isBlank, isPresent} from '../facade/lang';
+import {isArray, isBlank, isPresent} from '../facade/lang';
 import {reflector} from '../reflection/reflection';
+import {Type} from '../type';
 
 import {resolveForwardRef} from './forward_ref';
 import {DependencyMetadata, HostMetadata, InjectMetadata, OptionalMetadata, SelfMetadata, SkipSelfMetadata} from './metadata';
@@ -18,6 +19,7 @@ import {InvalidProviderError, MixingMultiProvidersWithRegularProvidersError, NoA
 import {ReflectiveKey} from './reflective_key';
 
 
+
 /**
  * `Dependency` is used by the framework to extend DI.
  * This is internal to Angular and should not be used directly.
@@ -54,7 +56,7 @@ const _EMPTY_LIST: any[] = [];
  */
 export interface ResolvedReflectiveProvider {
   /**
-   * A key, usually a `Type`.
+   * A key, usually a `Type<any>`.
    */
   key: ReflectiveKey;
 
@@ -140,7 +142,7 @@ export function resolveReflectiveProvider(provider: Provider): ResolvedReflectiv
  * Resolve a list of Providers.
  */
 export function resolveReflectiveProviders(
-    providers: Array<Type|Provider|{[k: string]: any}|any[]>): ResolvedReflectiveProvider[] {
+    providers: Array<Type<any>|Provider|{[k: string]: any}|any[]>): ResolvedReflectiveProvider[] {
   var normalized = _normalizeProviders(providers, []);
   var resolved = normalized.map(resolveReflectiveProvider);
   return MapWrapper.values(
@@ -185,7 +187,7 @@ export function mergeResolvedReflectiveProviders(
 }
 
 function _normalizeProviders(
-    providers: Array<Type|Provider|{[k: string]: any}|ProviderBuilder|any[]>,
+    providers: Array<Type<any>|Provider|{[k: string]: any}|ProviderBuilder|any[]>,
     res: Provider[]): Provider[] {
   providers.forEach(b => {
     if (b instanceof Type) {