refactor(testing): introduce new testing api to support ng modules

BREAKING CHANGE:
- deprecations:
  * `withProviders`, use `TestBed.withModule` instead
  * `addProviders`, use `TestBed.configureTestingModule` instead
  * `TestComponentBuilder`, use `TestBed.configureTestModule` / `TestBed.override...` / `TestBed.createComponent` instead.

Closes #10354

modules/@angular/compiler/testing.ts

@@ -10,12 +10,86 @@ export * from './testing/schema_registry_mock';
 export * from './testing/test_component_builder';
 export * from './testing/directive_resolver_mock';
 export * from './testing/ng_module_resolver_mock';
+export * from './testing/pipe_resolver_mock';
 
-import {createPlatformFactory, CompilerOptions, PlatformRef} from '@angular/core';
-import {platformCoreDynamic, DirectiveResolver, NgModuleResolver} from './index';
+import {ConcreteType, Type} from './src/facade/lang';
+import {createPlatformFactory, ModuleWithComponentFactories, Injectable, CompilerOptions, PlatformRef, CompilerFactory, ComponentFactory, NgModuleFactory, Injector, NgModuleMetadata, NgModuleMetadataType, ComponentMetadata, ComponentMetadataType, DirectiveMetadata, DirectiveMetadataType, PipeMetadata, PipeMetadataType} from '@angular/core';
+import {MetadataOverride} from '@angular/core/testing';
+import {TestingCompilerFactory, TestingCompiler} from './core_private_testing';
+import {platformCoreDynamic, RuntimeCompiler, DirectiveResolver, NgModuleResolver, PipeResolver} from './index';
 import {MockDirectiveResolver} from './testing/directive_resolver_mock';
 import {MockNgModuleResolver} from './testing/ng_module_resolver_mock';
+import {MockPipeResolver} from './testing/pipe_resolver_mock';
+import {MetadataOverrider} from './testing/metadata_overrider';
 
+@Injectable()
+export class TestingCompilerFactoryImpl implements TestingCompilerFactory {
+  constructor(private _compilerFactory: CompilerFactory) {}
+
+  createTestingCompiler(options: CompilerOptions[]): TestingCompiler {
+    const compiler = <RuntimeCompiler>this._compilerFactory.createCompiler(options);
+    return new TestingCompilerImpl(
+        compiler, compiler.injector.get(MockDirectiveResolver),
+        compiler.injector.get(MockPipeResolver), compiler.injector.get(MockNgModuleResolver));
+  }
+}
+
+export class TestingCompilerImpl implements TestingCompiler {
+  private _overrider = new MetadataOverrider();
+  constructor(
+      private _compiler: RuntimeCompiler, private _directiveResolver: MockDirectiveResolver,
+      private _pipeResolver: MockPipeResolver, private _moduleResolver: MockNgModuleResolver) {}
+  get injector(): Injector { return this._compiler.injector; }
+  compileComponentAsync<T>(component: ConcreteType<T>, ngModule: Type = null):
+      Promise<ComponentFactory<T>> {
+    return this._compiler.compileComponentAsync(component, <any>ngModule);
+  }
+  compileComponentSync<T>(component: ConcreteType<T>, ngModule: Type = null): ComponentFactory<T> {
+    return this._compiler.compileComponentSync(component, <any>ngModule);
+  }
+  compileModuleSync<T>(moduleType: ConcreteType<T>): NgModuleFactory<T> {
+    return this._compiler.compileModuleSync(moduleType);
+  }
+
+  compileModuleAsync<T>(moduleType: ConcreteType<T>): Promise<NgModuleFactory<T>> {
+    return this._compiler.compileModuleAsync(moduleType);
+  }
+  compileModuleAndAllComponentsSync<T>(moduleType: ConcreteType<T>):
+      ModuleWithComponentFactories<T> {
+    return this._compiler.compileModuleAndAllComponentsSync(moduleType);
+  }
+
+  compileModuleAndAllComponentsAsync<T>(moduleType: ConcreteType<T>):
+      Promise<ModuleWithComponentFactories<T>> {
+    return this._compiler.compileModuleAndAllComponentsAsync(moduleType);
+  }
+
+  overrideModule(ngModule: ConcreteType<any>, override: MetadataOverride<NgModuleMetadataType>):
+      void {
+    const oldMetadata = this._moduleResolver.resolve(ngModule, false);
+    this._moduleResolver.setNgModule(
+        ngModule, this._overrider.overrideMetadata(NgModuleMetadata, oldMetadata, override));
+  }
+  overrideDirective(
+      directive: ConcreteType<any>, override: MetadataOverride<DirectiveMetadataType>): void {
+    const oldMetadata = this._directiveResolver.resolve(directive, false);
+    this._directiveResolver.setDirective(
+        directive, this._overrider.overrideMetadata(DirectiveMetadata, oldMetadata, override));
+  }
+  overrideComponent(
+      component: ConcreteType<any>, override: MetadataOverride<ComponentMetadataType>): void {
+    const oldMetadata = this._directiveResolver.resolve(component, false);
+    this._directiveResolver.setDirective(
+        component, this._overrider.overrideMetadata(ComponentMetadata, oldMetadata, override));
+  }
+  overridePipe(pipe: ConcreteType<any>, override: MetadataOverride<PipeMetadataType>): void {
+    const oldMetadata = this._pipeResolver.resolve(pipe, false);
+    this._pipeResolver.setPipe(
+        pipe, this._overrider.overrideMetadata(PipeMetadata, oldMetadata, override));
+  }
+  clearCache(): void { this._compiler.clearCache(); }
+  clearCacheFor(type: Type) { this._compiler.clearCacheFor(type); }
+}
 
 /**
  * Platform for dynamic tests
@@ -23,13 +97,17 @@ import {MockNgModuleResolver} from './testing/ng_module_resolver_mock';
  * @experimental
  */
 export const platformCoreDynamicTesting =
-    createPlatformFactory(platformCoreDynamic, 'coreDynamicTesting', [{
-                            provide: CompilerOptions,
-                            useValue: {
-                              providers: [
-                                {provide: DirectiveResolver, useClass: MockDirectiveResolver},
-                                {provide: NgModuleResolver, useClass: MockNgModuleResolver}
-                              ]
-                            },
-                            multi: true
-                          }]);
+    createPlatformFactory(platformCoreDynamic, 'coreDynamicTesting', [
+      {
+        provide: CompilerOptions,
+        useValue: {
+          providers: [
+            MockPipeResolver, {provide: PipeResolver, useExisting: MockPipeResolver},
+            MockDirectiveResolver, {provide: DirectiveResolver, useExisting: MockDirectiveResolver},
+            MockNgModuleResolver, {provide: NgModuleResolver, useExisting: MockNgModuleResolver}
+          ]
+        },
+        multi: true
+      },
+      {provide: TestingCompilerFactory, useClass: TestingCompilerFactoryImpl}
+    ]);