feat(core): Add type information to injector.get() (#13785)

- Introduce `InjectionToken<T>` which is a parameterized and type-safe
  version of `OpaqueToken`.

DEPRECATION:
- `OpaqueToken` is now deprecated, use `InjectionToken<T>` instead.
- `Injector.get(token: any, notFoundValue?: any): any` is now deprecated
  use the same method which is now overloaded as
  `Injector.get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T): T;`.

Migration
- Replace `OpaqueToken` with `InjectionToken<?>` and parameterize it.
- Migrate your code to only use `Type<?>` or `InjectionToken<?>` as
  injection tokens. Using other tokens will not be supported in the
  future.

BREAKING CHANGE:
- Because `injector.get()` is now parameterize it is possible that code
  which used to work no longer type checks. Example would be if one
  injects `Foo` but configures it as `{provide: Foo, useClass: MockFoo}`.
  The injection instance will be that of `MockFoo` but the type will be
  `Foo` instead of `any` as in the past. This means that it was possible
  to call a method on `MockFoo` in the past which now will fail type
  check. See this example:

```
class Foo {}
class MockFoo extends Foo {
  setupMock();
}

var PROVIDERS = [
  {provide: Foo, useClass: MockFoo}
];

...

function myTest(injector: Injector) {
  var foo = injector.get(Foo);
  // This line used to work since `foo` used to be `any` before this
  // change, it will now be `Foo`, and `Foo` does not have `setUpMock()`.
  // The fix is to downcast: `injector.get(Foo) as MockFoo`.
  foo.setUpMock();
}
```

PR Close #13785

modules/@angular/core/test/linker/integration_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {CommonModule} from '@angular/common';
-import {ComponentFactory, Host, Inject, Injectable, Injector, NO_ERRORS_SCHEMA, NgModule, OnDestroy, OpaqueToken, ReflectiveInjector, SkipSelf} from '@angular/core';
+import {ComponentFactory, Host, Inject, Injectable, InjectionToken, Injector, NO_ERRORS_SCHEMA, NgModule, OnDestroy, ReflectiveInjector, SkipSelf} from '@angular/core';
 import {ChangeDetectionStrategy, ChangeDetectorRef, PipeTransform} from '@angular/core/src/change_detection/change_detection';
 import {ComponentFactoryResolver} from '@angular/core/src/linker/component_factory_resolver';
 import {ElementRef} from '@angular/core/src/linker/element_ref';
@@ -25,7 +25,7 @@ import {expect} from '@angular/platform-browser/testing/matchers';
 import {EventEmitter} from '../../src/facade/async';
 import {isBlank, isPresent, stringify} from '../../src/facade/lang';
 
-const ANCHOR_ELEMENT = new OpaqueToken('AnchorElement');
+const ANCHOR_ELEMENT = new InjectionToken('AnchorElement');
 
 export function main() {
   describe('jit', () => { declareTests({useJit: true}); });

modules/@angular/core/test/linker/ng_module_integration_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ANALYZE_FOR_ENTRY_COMPONENTS, CUSTOM_ELEMENTS_SCHEMA, Compiler, Component, ComponentFactoryResolver, Directive, HostBinding, Inject, Injectable, Injector, Input, NgModule, NgModuleRef, Optional, Pipe, Provider, Self, Type, forwardRef, getModuleFactory} from '@angular/core';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, CUSTOM_ELEMENTS_SCHEMA, Compiler, Component, ComponentFactoryResolver, Directive, HostBinding, Inject, Injectable, InjectionToken, Injector, Input, NgModule, NgModuleRef, Optional, Pipe, Provider, Self, Type, forwardRef, getModuleFactory} from '@angular/core';
 import {Console} from '@angular/core/src/console';
 import {ComponentFixture, TestBed, inject} from '@angular/core/testing';
 import {expect} from '@angular/platform-browser/testing/matchers';
@@ -30,6 +30,7 @@ class Dashboard {
 
 class TurboEngine extends Engine {}
 
+const CARS = new InjectionToken<Car[]>('Cars');
 @Injectable()
 class Car {
   engine: Engine;
@@ -692,11 +693,11 @@ function declareTests({useJit}: {useJit: boolean}) {
 
       it('should support multiProviders', () => {
         const injector = createInjector([
-          Engine, {provide: Car, useClass: SportsCar, multi: true},
-          {provide: Car, useClass: CarWithOptionalEngine, multi: true}
+          Engine, {provide: CARS, useClass: SportsCar, multi: true},
+          {provide: CARS, useClass: CarWithOptionalEngine, multi: true}
         ]);
 
-        const cars = injector.get(Car);
+        const cars = injector.get(CARS);
         expect(cars.length).toEqual(2);
         expect(cars[0]).toBeAnInstanceOf(SportsCar);
         expect(cars[1]).toBeAnInstanceOf(CarWithOptionalEngine);
@@ -704,9 +705,9 @@ function declareTests({useJit}: {useJit: boolean}) {
 
       it('should support multiProviders that are created using useExisting', () => {
         const injector = createInjector(
-            [Engine, SportsCar, {provide: Car, useExisting: SportsCar, multi: true}]);
+            [Engine, SportsCar, {provide: CARS, useExisting: SportsCar, multi: true}]);
 
-        const cars = injector.get(Car);
+        const cars = injector.get(CARS);
         expect(cars.length).toEqual(1);
         expect(cars[0]).toBe(injector.get(SportsCar));
       });

modules/@angular/core/test/linker/regression_integration_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ANALYZE_FOR_ENTRY_COMPONENTS, Component, Injector, OpaqueToken, Pipe, PipeTransform, Provider} from '@angular/core';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, Component, InjectionToken, Injector, Pipe, PipeTransform, Provider} from '@angular/core';
 import {TestBed} from '@angular/core/testing';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
@@ -104,8 +104,8 @@ function declareTests({useJit}: {useJit: boolean}) {
         return TestBed.createComponent(MyComp1).componentInstance.injector;
       }
 
-      it('should support providers with an OpaqueToken that contains a `.` in the name', () => {
-        const token = new OpaqueToken('a.b');
+      it('should support providers with an InjectionToken that contains a `.` in the name', () => {
+        const token = new InjectionToken('a.b');
         const tokenValue = 1;
         const injector = createInjector([{provide: token, useValue: tokenValue}]);
         expect(injector.get(token)).toEqual(tokenValue);
@@ -127,9 +127,9 @@ function declareTests({useJit}: {useJit: boolean}) {
         expect(injector.get(token)).toEqual(tokenValue);
       });
 
-      it('should support providers with an OpaqueToken that has a StringMap as value', () => {
-        const token1 = new OpaqueToken('someToken');
-        const token2 = new OpaqueToken('someToken');
+      it('should support providers with an InjectionToken that has a StringMap as value', () => {
+        const token1 = new InjectionToken('someToken');
+        const token2 = new InjectionToken('someToken');
         const tokenValue1 = {'a': 1};
         const tokenValue2 = {'a': 1};
         const injector = createInjector(