Revert "feat(ivy): add support of ApplicationRef.bootstrapModuleFactory (angular#23811)"

This reverts commit 22b58a7.
This commit causes a breakage in g3.

Author: vicb

packages/core/src/application_module.ts

@@ -10,15 +10,11 @@ import {APP_INITIALIZER, ApplicationInitStatus} from './application_init';
 import {ApplicationRef} from './application_ref';
 import {APP_ID_RANDOM_PROVIDER} from './application_tokens';
 import {IterableDiffers, KeyValueDiffers, defaultIterableDiffers, defaultKeyValueDiffers} from './change_detection/change_detection';
-import {Console} from './console';
-import {InjectionToken, Injector, StaticProvider} from './di';
+import {forwardRef} from './di/forward_ref';
 import {Inject, Optional, SkipSelf} from './di/metadata';
-import {ErrorHandler} from './error_handler';
 import {LOCALE_ID} from './i18n/tokens';
-import {ComponentFactoryResolver} from './linker';
 import {Compiler} from './linker/compiler';
 import {NgModule} from './metadata';
-import {NgZone} from './zone';
 
 export function _iterableDiffersFactory() {
   return defaultIterableDiffers;
@@ -32,36 +28,27 @@ export function _localeFactory(locale?: string): string {
   return locale || 'en-US';
 }
 
-export const APPLICATION_MODULE_PROVIDERS: StaticProvider[] = [
-  {
-    provide: ApplicationRef,
-    useClass: ApplicationRef,
-    deps:
-        [NgZone, Console, Injector, ErrorHandler, ComponentFactoryResolver, ApplicationInitStatus]
-  },
-  {
-    provide: ApplicationInitStatus,
-    useClass: ApplicationInitStatus,
-    deps: [[new Optional(), APP_INITIALIZER]]
-  },
-  {provide: Compiler, useClass: Compiler, deps: []},
-  APP_ID_RANDOM_PROVIDER,
-  {provide: IterableDiffers, useFactory: _iterableDiffersFactory, deps: []},
-  {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory, deps: []},
-  {
-    provide: LOCALE_ID,
-    useFactory: _localeFactory,
-    deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
-  },
-];
-
 /**
  * This module includes the providers of @angular/core that are needed
  * to bootstrap components via `ApplicationRef`.
  *
  * @experimental
  */
-@NgModule({providers: APPLICATION_MODULE_PROVIDERS})
+@NgModule({
+  providers: [
+    ApplicationRef,
+    ApplicationInitStatus,
+    Compiler,
+    APP_ID_RANDOM_PROVIDER,
+    {provide: IterableDiffers, useFactory: _iterableDiffersFactory},
+    {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory},
+    {
+      provide: LOCALE_ID,
+      useFactory: _localeFactory,
+      deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
+    },
+  ],
+})
 export class ApplicationModule {
   // Inject ApplicationRef to make it eager...
   constructor(appRef: ApplicationRef) {}

packages/core/src/core_render3_private_export.ts

@@ -23,8 +23,6 @@ export {
   injectAttribute as ɵinjectAttribute,
   PublicFeature as ɵPublicFeature,
   NgOnChangesFeature as ɵNgOnChangesFeature,
-  NgModuleDef as ɵNgModuleDef,
-  NgModuleType as ɵNgModuleType,
   CssSelectorList as ɵCssSelectorList,
   markDirty as ɵmarkDirty,
   NC as ɵNC,

packages/core/src/di.ts

@@ -18,7 +18,7 @@ export {forwardRef, resolveForwardRef, ForwardRefFn} from './di/forward_ref';
 export {Injectable, InjectableDecorator, InjectableProvider} from './di/injectable';
 export {inject, InjectFlags, INJECTOR, Injector} from './di/injector';
 export {ReflectiveInjector} from './di/reflective_injector';
-export {StaticProvider, ValueProvider, ConstructorSansProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ClassProvider} from './di/provider';
+export {StaticProvider, ValueProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ClassProvider} from './di/provider';
 export {createInjector} from './di/r3_injector';
 export {ResolvedReflectiveFactory, ResolvedReflectiveProvider} from './di/reflective_provider';
 export {ReflectiveKey} from './di/reflective_key';

packages/core/src/di/injector.ts

@@ -32,9 +32,6 @@ export const INJECTOR = new InjectionToken<Injector>('INJECTOR');
 export class NullInjector implements Injector {
   get(token: any, notFoundValue: any = _THROW_IF_NOT_FOUND): any {
     if (notFoundValue === _THROW_IF_NOT_FOUND) {
-      // Intentionally left behind: With dev tools open the debugger will stop here. There is no
-      // reason why correctly written application should cause this exception.
-      debugger;
       throw new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
     }
     return notFoundValue;
@@ -490,11 +487,11 @@ export function injectArgs(types: (Type<any>| InjectionToken<any>| any[])[]): an
 
       for (let j = 0; j < arg.length; j++) {
         const meta = arg[j];
-        if (meta instanceof Optional || meta.ngMetadataName === 'Optional') {
+        if (meta instanceof Optional || meta.__proto__.ngMetadataName === 'Optional') {
           flags |= InjectFlags.Optional;
-        } else if (meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf') {
+        } else if (meta instanceof SkipSelf || meta.__proto__.ngMetadataName === 'SkipSelf') {
           flags |= InjectFlags.SkipSelf;
-        } else if (meta instanceof Self || meta.ngMetadataName === 'Self') {
+        } else if (meta instanceof Self || meta.__proto__.ngMetadataName === 'Self') {
           flags |= InjectFlags.Self;
         } else if (meta instanceof Inject) {
           type = meta.token;

packages/core/src/di/provider.ts

@@ -151,6 +151,10 @@ export interface StaticClassProvider extends StaticClassSansProvider {
  *
  * For more details, see the {@linkDocs guide/dependency-injection "Dependency Injection Guide"}.
  *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorSansProvider'}
+ *
  * @experimental
  */
 export interface ConstructorSansProvider {
@@ -449,5 +453,5 @@ export interface ClassProvider extends ClassSansProvider {
  *
  *
  */
-export type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider |
-    ExistingProvider | FactoryProvider | any[];
+export type Provider =
+    TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];

packages/core/src/di/r3_injector.ts

@@ -14,7 +14,7 @@ import {InjectableDef, InjectableType, InjectorDef, InjectorType, InjectorTypeWi
 import {resolveForwardRef} from './forward_ref';
 import {InjectableDefToken, InjectionToken} from './injection_token';
 import {INJECTOR, InjectFlags, Injector, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, inject, injectArgs, setCurrentInjector} from './injector';
-import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, Provider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider} from './provider';
+import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, Provider, StaticClassProvider, TypeProvider, ValueProvider} from './provider';
 import {APP_ROOT} from './scope';
 
 
@@ -64,15 +64,14 @@ interface Record<T> {
 }
 
 /**
- * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
+ * Create a new `Injector` which is configured using `InjectorType`s.
  *
  * @experimental
  */
 export function createInjector(
-    defType: /* InjectorType<any> */ any, parent: Injector | null = null,
-    additionalProviders: StaticProvider[] | null = null): Injector {
+    defType: /* InjectorType<any> */ any, parent: Injector | null = null): Injector {
   parent = parent || getNullInjector();
-  return new R3Injector(defType, additionalProviders, parent);
+  return new R3Injector(defType, parent);
 }
 
 export class R3Injector {
@@ -102,18 +101,12 @@ export class R3Injector {
    */
   private destroyed = false;
 
-  constructor(
-      def: InjectorType<any>, additionalProviders: StaticProvider[]|null,
-      readonly parent: Injector) {
+  constructor(def: InjectorType<any>, readonly parent: Injector) {
     // Start off by creating Records for every provider declared in every InjectorType
     // included transitively in `def`.
     deepForEach(
         [def], injectorDef => this.processInjectorType(injectorDef, new Set<InjectorType<any>>()));
 
-    additionalProviders &&
-        deepForEach(additionalProviders, provider => this.processProvider(provider));
-
-
     // Make sure the INJECTOR token provides this injector.
     this.records.set(INJECTOR, makeRecord(undefined, this));
 
@@ -291,18 +284,20 @@ export class R3Injector {
           throw new Error(`Mixed multi-provider for ${token}.`);
         }
       } else {
+        token = provider;
         multiRecord = makeRecord(undefined, NOT_YET, true);
         multiRecord.factory = () => injectArgs(multiRecord !.multi !);
         this.records.set(token, multiRecord);
       }
       token = provider;
       multiRecord.multi !.push(provider);
-    } else {
-      const existing = this.records.get(token);
-      if (existing && existing.multi !== undefined) {
-        throw new Error(`Mixed multi-provider for ${stringify(token)}`);
-      }
     }
+
+    const existing = this.records.get(token);
+    if (existing && existing.multi !== undefined) {
+      throw new Error(`Mixed multi-provider for ${token}`);
+    }
+
     this.records.set(token, record);
   }
 

packages/core/src/render3/assert.ts

@@ -46,13 +46,13 @@ export function assertGreaterThan<T>(actual: T, expected: T, msg: string) {
   }
 }
 
-export function assertNotDefined<T>(actual: T, msg: string) {
+export function assertNull<T>(actual: T, msg: string) {
   if (actual != null) {
     throwError(msg);
   }
 }
 
-export function assertDefined<T>(actual: T, msg: string) {
+export function assertNotNull<T>(actual: T, msg: string) {
   if (actual == null) {
     throwError(msg);
   }

packages/core/src/render3/component.ts

@@ -13,7 +13,7 @@ import {Injector} from '../di/injector';
 import {ComponentRef as viewEngine_ComponentRef} from '../linker/component_factory';
 import {Sanitizer} from '../sanitization/security';
 
-import {assertComponentType, assertDefined} from './assert';
+import {assertComponentType, assertNotNull} from './assert';
 import {queueInitHooks, queueLifecycleHooks} from './hooks';
 import {CLEAN_PROMISE, ROOT_DIRECTIVE_INDICES, _getComponentHostLElementNode, baseDirectiveCreate, createLView, createTView, detectChangesInternal, enterView, executeInitAndContentHooks, getRootView, hostElement, initChangeDetectorIfExisting, leaveView, locateHostElement, setHostBindings} from './instructions';
 import {ComponentDef, ComponentType} from './interfaces/definition';
@@ -72,6 +72,31 @@ export interface CreateComponentOptions {
 }
 
 
+/**
+ * Bootstraps a component, then creates and returns a `ComponentRef` for that component.
+ *
+ * @param componentType Component to bootstrap
+ * @param options Optional parameters which control bootstrapping
+ */
+export function createComponentRef<T>(
+    componentType: ComponentType<T>, opts: CreateComponentOptions): viewEngine_ComponentRef<T> {
+  const component = renderComponent(componentType, opts);
+  const hostView = _getComponentHostLElementNode(component).data as LView;
+  const hostViewRef = new ViewRef(hostView, component);
+  return {
+    location: {nativeElement: getHostElement(component)},
+    injector: opts.injector || NULL_INJECTOR,
+    instance: component,
+    hostView: hostViewRef,
+    changeDetectorRef: hostViewRef,
+    componentType: componentType,
+    // TODO: implement destroy and onDestroy
+    destroy: () => {},
+    onDestroy: (cb: Function) => {}
+  };
+}
+
+
 // TODO: A hack to not pull in the NullInjector from @angular/core.
 export const NULL_INJECTOR: Injector = {
   get: (token: any, notFoundValue?: any) => {
@@ -106,8 +131,12 @@ export function renderComponent<T>(
   // The first index of the first selector is the tag name.
   const componentTag = componentDef.selectors ![0] ![0] as string;
   const hostNode = locateHostElement(rendererFactory, opts.host || componentTag);
-  const rootContext = createRootContext(opts.scheduler || requestAnimationFrame.bind(window));
-
+  const rootContext: RootContext = {
+    // Incomplete initialization due to circular reference.
+    component: null !,
+    scheduler: opts.scheduler || requestAnimationFrame.bind(window),
+    clean: CLEAN_PROMISE,
+  };
   const rootView: LView = createLView(
       rendererFactory.createRenderer(hostNode, componentDef.rendererType),
       createTView(-1, null, null, null), rootContext,
@@ -123,8 +152,8 @@ export function renderComponent<T>(
     elementNode = hostElement(componentTag, hostNode, componentDef, sanitizer);
 
     // Create directive instance with factory() and store at index 0 in directives array
-    rootContext.components.push(
-        component = baseDirectiveCreate(0, componentDef.factory(), componentDef) as T);
+    component = rootContext.component =
+        baseDirectiveCreate(0, componentDef.factory(), componentDef) as T;
     initChangeDetectorIfExisting(elementNode.nodeInjector, component, elementNode.data !);
 
     opts.hostFeatures && opts.hostFeatures.forEach((feature) => feature(component, componentDef));
@@ -140,14 +169,6 @@ export function renderComponent<T>(
   return component;
 }
 
-export function createRootContext(scheduler: (workFn: () => void) => void): RootContext {
-  return {
-    components: [],
-    scheduler: scheduler,
-    clean: CLEAN_PROMISE,
-  };
-}
-
 /**
  * Used to enable lifecycle hooks on the root component.
  *
@@ -177,7 +198,7 @@ export function LifecycleHooksFeature(component: any, def: ComponentDef<any>): v
  */
 function getRootContext(component: any): RootContext {
   const rootContext = getRootView(component).context as RootContext;
-  ngDevMode && assertDefined(rootContext, 'rootContext');
+  ngDevMode && assertNotNull(rootContext, 'rootContext');
   return rootContext;
 }