feat(core): introduce @AppModule

Main part for #9726
Closes #9730

modules/@angular/core/src/linker/app_module_factory.ts

@@ -0,0 +1,90 @@
+/**
+ * @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 {Injector, THROW_IF_NOT_FOUND} from '../di/injector';
+import {unimplemented} from '../facade/exceptions';
+import {ConcreteType} from '../facade/lang';
+
+import {ComponentFactory} from './component_factory';
+import {CodegenComponentFactoryResolver, ComponentFactoryResolver} from './component_factory_resolver';
+
+
+/**
+ * Represents an instance of an AppModule created via a {@link AppModuleFactory}.
+ *
+ * `AppModuleRef` provides access to the AppModule Instance as well other objects related to this
+ * AppModule Instance.
+ * @stable
+ */
+export abstract class AppModuleRef<T> {
+  /**
+   * The injector that contains all of the providers of the AppModule.
+   */
+  get injector(): Injector { return unimplemented(); }
+
+  /**
+   * The ComponentFactoryResolver to get hold of the ComponentFactories
+   * delcared in the `precompile` property of the module.
+   */
+  get componentFactoryResolver(): ComponentFactoryResolver { return unimplemented(); }
+
+  /**
+   * The AppModule instance.
+   */
+  get instance(): T { return unimplemented(); }
+}
+
+/**
+ * @stable
+ */
+export class AppModuleFactory<T> {
+  constructor(
+      private _injectorClass: {new (parentInjector: Injector): AppModuleInjector<T>},
+      private _moduleype: ConcreteType<T>) {}
+
+  get moduleType(): ConcreteType<T> { return this._moduleype; }
+
+  create(parentInjector: Injector = null): AppModuleRef<T> {
+    if (!parentInjector) {
+      parentInjector = Injector.NULL;
+    }
+    var instance = new this._injectorClass(parentInjector);
+    instance.create();
+    return instance;
+  }
+}
+
+const _UNDEFINED = new Object();
+
+export abstract class AppModuleInjector<T> extends CodegenComponentFactoryResolver implements
+    Injector,
+    AppModuleRef<T> {
+  public instance: T;
+
+  constructor(public parent: Injector, factories: ComponentFactory<any>[]) {
+    super(factories, parent.get(ComponentFactoryResolver, ComponentFactoryResolver.NULL));
+  }
+
+  create() { this.instance = this.createInternal(); }
+
+  abstract createInternal(): T;
+
+  get(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {
+    if (token === Injector || token === ComponentFactoryResolver) {
+      return this;
+    }
+    var result = this.getInternal(token, _UNDEFINED);
+    return result === _UNDEFINED ? this.parent.get(token, notFoundValue) : result;
+  }
+
+  abstract getInternal(token: any, notFoundValue: any): any;
+
+  get injector(): Injector { return this; }
+
+  get componentFactoryResolver(): ComponentFactoryResolver { return this; }
+}

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

@@ -8,7 +8,9 @@
 
 import {BaseException} from '../facade/exceptions';
 import {ConcreteType, Type, stringify} from '../facade/lang';
+import {AppModuleMetadata} from '../metadata/app_module';
 
+import {AppModuleFactory} from './app_module_factory';
 import {ComponentFactory} from './component_factory';
 
 
@@ -22,7 +24,10 @@ export class Compiler {
   /**
    * Loads the template and styles of a component and returns the associated `ComponentFactory`.
    */
-  compileComponentAsync<T>(component: ConcreteType<T>): Promise<ComponentFactory<T>> {
+  compileComponentAsync<T>(component: ConcreteType<T>, {moduleDirectives = [], modulePipes = []}: {
+    moduleDirectives?: ConcreteType<any>[],
+    modulePipes?: ConcreteType<any>[]
+  } = {}): Promise<ComponentFactory<T>> {
     throw new BaseException(
         `Runtime compiler is not loaded. Tried to compile ${stringify(component)}`);
   }
@@ -30,16 +35,37 @@ export class Compiler {
    * Compiles the given component. All templates have to be either inline or compiled via
    * `compileComponentAsync` before.
    */
-  compileComponentSync<T>(component: ConcreteType<T>): ComponentFactory<T> {
+  compileComponentSync<T>(component: ConcreteType<T>, {moduleDirectives = [], modulePipes = []}: {
+    moduleDirectives?: ConcreteType<any>[],
+    modulePipes?: ConcreteType<any>[]
+  } = {}): ComponentFactory<T> {
     throw new BaseException(
         `Runtime compiler is not loaded. Tried to compile ${stringify(component)}`);
   }
+  /**
+   * Compiles the given App Module. All templates of the components listed in `precompile`
+   * have to be either inline or compiled before via `compileComponentAsync` /
+   * `compileAppModuleAsync`.
+   */
+  compileAppModuleSync<T>(moduleType: ConcreteType<T>, metadata: AppModuleMetadata = null):
+      AppModuleFactory<T> {
+    throw new BaseException(
+        `Runtime compiler is not loaded. Tried to compile ${stringify(moduleType)}`);
+  }
+
+  compileAppModuleAsync<T>(moduleType: ConcreteType<T>, metadata: AppModuleMetadata = null):
+      Promise<AppModuleFactory<T>> {
+    throw new BaseException(
+        `Runtime compiler is not loaded. Tried to compile ${stringify(moduleType)}`);
+  }
+
   /**
    * Clears all caches
    */
   clearCache(): void {}
+
   /**
-   * Clears the cache for the given component.
+   * Clears the cache for the given component/appModule.
    */
-  clearCacheFor(compType: Type) {}
+  clearCacheFor(type: Type) {}
 }