refactor(core): deprecate coreBootstrap, PLATFORM_PIPES/DIRECTIVES providers and ComponentResolver

BREAKING CHANGE (deprecations)

- Instead of `coreBootstrap`, create an `@AppModule` and use `bootstrapModule`.
- Instead of `coreLoadAndBootstarp`, create an `@AppModule` and use `bootstrapModuleFactory`.
- Instead of `bootstrapWorkerApp`, create an `@AppModule` that includes the `WorkerAppModule` and use `bootstrapModule` with the `workerAppPlatform()`.
- Instead of `bootstrapWorkerUi`, create an @AppModule that includes the `WorkerUiModule` and use `bootstrapModule` with the `workerUiPlatform()` instead.
- Instead of `serverBootstrap`, create an @AppModule and use `bootstrapModule` with the `serverDynamicPlatform()` instead.
- Instead of `PLATFORM_PIPES` and `PLATFORM_DIRECTIVES`, provide platform directives/pipes via an `@AppModule`.
- Instead of `ComponentResolver`:
  - use `ComponentFactoryResolver` together with `@AppModule.precompile`/`@Component.precompile` or `ANALYZE_FOR_PRECOMPILE` provider for dynamic component creation.
  - use `AppModuleFactoryLoader` for lazy loading.
- Instead of `SystemJsComponentResolver`, create an `@AppModule` and use `SystemJsAppModuleLoader`.
- Instead of `SystemJsCmpFactoryResolver`, create an `@AppModule` and use `SystemJsAppModuleFactoryLoader`

Closes #9726

modules/@angular/compiler/src/compiler.ts

@@ -92,8 +92,8 @@ export class _RuntimeCompilerFactory extends CompilerFactory {
       const inj = ReflectiveInjector.resolveAndCreate(options.deprecatedAppProviders);
       const compilerConfig: CompilerConfig = inj.get(CompilerConfig, null);
       if (compilerConfig) {
-        platformDirectivesFromAppProviders = compilerConfig.platformDirectives;
-        platformPipesFromAppProviders = compilerConfig.platformPipes;
+        platformDirectivesFromAppProviders = compilerConfig.deprecatedPlatformDirectives;
+        platformPipesFromAppProviders = compilerConfig.deprecatedPlatformPipes;
         useJitFromAppProviders = compilerConfig.useJit;
         useDebugFromAppProviders = compilerConfig.genDebugInfo;
         defaultEncapsulationFromAppProviders = compilerConfig.defaultEncapsulation;
@@ -133,9 +133,9 @@ export class _RuntimeCompilerFactory extends CompilerFactory {
         provide: CompilerConfig,
         useFactory: (platformDirectives: any[], platformPipes: any[]) => {
           return new CompilerConfig({
-            platformDirectives:
+            deprecatedPlatformDirectives:
                 _mergeArrays(platformDirectivesFromAppProviders, platformDirectives),
-            platformPipes: _mergeArrays(platformPipesFromAppProviders, platformPipes),
+            deprecatedPlatformPipes: _mergeArrays(platformPipesFromAppProviders, platformPipes),
             // let explicit values from the compiler options overwrite options
             // from the app providers. E.g. important for the testing platform.
             genDebugInfo: _firstDefined(options.useDebug, useDebugFromAppProviders, isDevMode()),

modules/@angular/compiler/src/config.ts

@@ -19,28 +19,38 @@ export class CompilerConfig {
   private _genDebugInfo: boolean;
   private _logBindingUpdate: boolean;
   public useJit: boolean;
-  public platformDirectives: any[];
-  public platformPipes: any[];
+  /**
+   * @deprecated Providing platform directives via the {@link CompilerConfig} deprecated. Provide
+   * platform
+   * directives via an {@link AppModule} instead.
+   */
+  public deprecatedPlatformDirectives: any[];
+  /**
+   * @deprecated Providing platform pipes via the {@link CompilerConfig} deprecated. Provide
+   * platform pipes
+   * via an {@link AppModule} instead.
+   */
+  public deprecatedPlatformPipes: any[];
 
   constructor(
       {renderTypes = new DefaultRenderTypes(), defaultEncapsulation = ViewEncapsulation.Emulated,
-       genDebugInfo, logBindingUpdate, useJit = true, platformDirectives = [],
-       platformPipes = []}: {
+       genDebugInfo, logBindingUpdate, useJit = true, deprecatedPlatformDirectives = [],
+       deprecatedPlatformPipes = []}: {
         renderTypes?: RenderTypes,
         defaultEncapsulation?: ViewEncapsulation,
         genDebugInfo?: boolean,
         logBindingUpdate?: boolean,
         useJit?: boolean,
-        platformDirectives?: any[],
-        platformPipes?: any[]
+        deprecatedPlatformDirectives?: any[],
+        deprecatedPlatformPipes?: any[]
       } = {}) {
     this.renderTypes = renderTypes;
     this.defaultEncapsulation = defaultEncapsulation;
     this._genDebugInfo = genDebugInfo;
     this._logBindingUpdate = logBindingUpdate;
     this.useJit = useJit;
-    this.platformDirectives = platformDirectives;
-    this.platformPipes = platformPipes;
+    this.deprecatedPlatformDirectives = deprecatedPlatformDirectives;
+    this.deprecatedPlatformPipes = deprecatedPlatformPipes;
   }
 
   get genDebugInfo(): boolean {

modules/@angular/compiler/src/metadata_resolver.ts

@@ -301,7 +301,7 @@ export class CompileMetadataResolver {
 
   getViewDirectivesMetadata(component: Type): cpl.CompileDirectiveMetadata[] {
     var view = this._viewResolver.resolve(component);
-    var directives = flattenDirectives(view, this._config.platformDirectives);
+    var directives = flattenDirectives(view, this._config.deprecatedPlatformDirectives);
     for (var i = 0; i < directives.length; i++) {
       if (!isValidType(directives[i])) {
         throw new BaseException(
@@ -313,7 +313,7 @@ export class CompileMetadataResolver {
 
   getViewPipesMetadata(component: Type): cpl.CompilePipeMetadata[] {
     var view = this._viewResolver.resolve(component);
-    var pipes = flattenPipes(view, this._config.platformPipes);
+    var pipes = flattenPipes(view, this._config.deprecatedPlatformPipes);
     for (var i = 0; i < pipes.length; i++) {
       if (!isValidType(pipes[i])) {
         throw new BaseException(

modules/@angular/compiler/src/runtime_compiler.ts

@@ -7,6 +7,7 @@
  */
 
 import {AppModuleFactory, AppModuleMetadata, Compiler, ComponentFactory, ComponentResolver, ComponentStillLoadingError, Injectable, Injector, OptionalMetadata, Provider, SkipSelfMetadata} from '@angular/core';
+import {Console} from '../core_private';
 
 import {BaseException} from '../src/facade/exceptions';
 import {ConcreteType, IS_DART, Type, isBlank, isString, stringify} from '../src/facade/lang';
@@ -42,11 +43,28 @@ export class RuntimeCompiler implements ComponentResolver, Compiler {
   private _compiledHostTemplateCache = new Map<Type, CompiledTemplate>();
   private _compiledAppModuleCache = new Map<Type, AppModuleFactory<any>>();
 
+  private _warnOnComponentResolver = true;
+
   constructor(
       private _injector: Injector, private _metadataResolver: CompileMetadataResolver,
       private _templateNormalizer: DirectiveNormalizer, private _templateParser: TemplateParser,
       private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
-      private _appModuleCompiler: AppModuleCompiler, private _genConfig: CompilerConfig) {}
+      private _appModuleCompiler: AppModuleCompiler, private _genConfig: CompilerConfig,
+      private _console: Console) {
+    const flatDeprecatedPlatformDirectives =
+        ListWrapper.flatten(_genConfig.deprecatedPlatformDirectives);
+    if (flatDeprecatedPlatformDirectives.length > 0) {
+      this._console.warn(
+          `Providing platform directives via the PLATFORM_DIRECTIVES provider or the "CompilerConfig" is deprecated. Provide platform directives via an @AppModule instead. Directives: ` +
+          flatDeprecatedPlatformDirectives.map(stringify));
+    }
+    const flatDeprecatedPlatformPipes = ListWrapper.flatten(_genConfig.deprecatedPlatformPipes);
+    if (flatDeprecatedPlatformPipes.length > 0) {
+      this._console.warn(
+          `Providing platform pipes via the PLATFORM_PIPES provider or the "CompilerConfig" is deprecated. Provide platform pipes via an @AppModule instead. Pipes: ` +
+          flatDeprecatedPlatformPipes.map(stringify));
+    }
+  }
 
   get injector(): Injector { return this._injector; }
 
@@ -55,6 +73,10 @@ export class RuntimeCompiler implements ComponentResolver, Compiler {
       return PromiseWrapper.reject(
           new BaseException(`Cannot resolve component using '${component}'.`), null);
     }
+    if (this._warnOnComponentResolver) {
+      this._console.warn(ComponentResolver.DynamicCompilationDeprecationMsg);
+      this._warnOnComponentResolver = false;
+    }
     return this.compileComponentAsync(<ConcreteType<any>>component);
   }