fix(ivy): align discovery methods for consistency (angular#27117)

PR Close angular#27117

Author: mhevery

packages/core/src/change_detection/differs/keyvalue_differs.ts

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Optional, SkipSelf, StaticProvider} from '../../di';
+import {Optional, SkipSelf, StaticProvider, defineInjectable} from '../../di';
+import {DefaultKeyValueDifferFactory} from './default_keyvalue_differ';
 
 
 /**
@@ -116,6 +117,12 @@ export interface KeyValueDifferFactory {
  * @publicApi
  */
 export class KeyValueDiffers {
+  /** @nocollapse */
+  static ngInjectableDef = defineInjectable({
+    providedIn: 'root',
+    factory: () => new KeyValueDiffers([new DefaultKeyValueDifferFactory()])
+  });
+
   /**
    * @deprecated v4.0.0 - Should be private.
    */

packages/core/src/di/r3_injector.ts

@@ -200,6 +200,7 @@ export class R3Injector {
       defOrWrappedDef: InjectorType<any>|InjectorTypeWithProviders<any>,
       parents: InjectorType<any>[], dedupStack: InjectorType<any>[]) {
     defOrWrappedDef = resolveForwardRef(defOrWrappedDef);
+    if (!defOrWrappedDef) return;
 
     // Either the defOrWrappedDef is an InjectorType (with ngInjectorDef) or an
     // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic

packages/core/src/render3/component.ts

@@ -13,9 +13,10 @@ import {Injector} from '../di/injector';
 import {Sanitizer} from '../sanitization/security';
 
 import {assertComponentType, assertDefined} from './assert';
-import {getComponentViewByInstance} from './context_discovery';
+import {getContext} from './context_discovery';
 import {getComponentDef} from './definition';
 import {diPublicInInjector, getOrCreateNodeInjectorForNode} from './di';
+import {getHostElement} from './discovery_utils';
 import {publishDefaultGlobalUtils} from './global_utils';
 import {queueInitHooks, queueLifecycleHooks} from './hooks';
 import {CLEAN_PROMISE, createLViewData, createNodeAtIndex, createTView, getOrCreateTView, initNodeFlags, instantiateRootComponent, locateHostElement, prefillHostVars, queueComponentIndexForCheck, refreshDescendantViews} from './instructions';
@@ -28,6 +29,7 @@ import {enterView, leaveView, resetComponentState} from './state';
 import {defaultScheduler, getRootView, readElementValue, readPatchedLViewData, stringify} from './util';
 
 
+
 /** Options that control how the component should be bootstrapped. */
 export interface CreateComponentOptions {
   /** Which renderer factory to use. */
@@ -121,8 +123,8 @@ export function renderComponent<T>(
 
   const renderer = rendererFactory.createRenderer(hostRNode, componentDef);
   const rootView: LViewData = createLViewData(
-      renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, undefined,
-      opts.injector || null);
+      null, renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags,
+      undefined, opts.injector || null);
 
   const oldView = enterView(rootView, null);
   let component: T;
@@ -159,7 +161,7 @@ export function createRootComponentView(
   resetComponentState();
   const tView = rootView[TVIEW];
   const componentView = createLViewData(
-      renderer,
+      rootView, renderer,
       getOrCreateTView(
           def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery),
       null, def.onPush ? LViewFlags.Dirty : LViewFlags.CheckAlways, sanitizer);
@@ -243,32 +245,6 @@ function getRootContext(component: any): RootContext {
   return rootContext;
 }
 
-/**
- * Retrieve the host element of the component.
- *
- * Use this function to retrieve the host element of the component. The host
- * element is the element which the component is associated with.
- *
- * @param component Component for which the host element should be retrieved.
- */
-export function getHostElement<T>(component: T): HTMLElement {
-  return readElementValue(getComponentViewByInstance(component)) as HTMLElement;
-}
-
-/**
- * Retrieves the rendered text for a given component.
- *
- * This function retrieves the host element of a component and
- * and then returns the `textContent` for that element. This implies
- * that the text returned will include re-projected content of
- * the component as well.
- *
- * @param component The component to return the content text for.
- */
-export function getRenderedText(component: any): string {
-  const hostElement = getHostElement(component);
-  return hostElement.textContent || '';
-}
 
 /**
  * Wait on component until it is rendered.

packages/core/src/render3/component_ref.ts

@@ -151,8 +151,8 @@ export class ComponentFactory<T> extends viewEngine_ComponentFactory<T> {
 
     // Create the root view. Uses empty TView and ContentTemplate.
     const rootView: LViewData = createLViewData(
-        renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, undefined,
-        rootViewInjector);
+        null, renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags,
+        undefined, rootViewInjector);
 
     // rootView is the parent when bootstrapping
     const oldView = enterView(rootView, null);

packages/core/src/render3/context_discovery.ts

@@ -8,13 +8,15 @@
 import './ng_dev_mode';
 
 import {assertEqual} from './assert';
+import {EMPTY_ARRAY} from './definition';
 import {LContext, MONKEY_PATCH_KEY_NAME} from './interfaces/context';
 import {TNode, TNodeFlags} from './interfaces/node';
 import {RElement} from './interfaces/renderer';
 import {CONTEXT, HEADER_OFFSET, HOST, LViewData, TVIEW} from './interfaces/view';
 import {getComponentViewByIndex, getNativeByTNode, readElementValue, readPatchedData} from './util';
 
 
+
 /** Returns the matching `LContext` data for a given DOM node, directive or component instance.
  *
  * This function will examine the provided DOM element, component, or directive instance\'s
@@ -31,6 +33,8 @@ import {getComponentViewByIndex, getNativeByTNode, readElementValue, readPatched
  * will be updated with a new context (which is then returned). If the monkey-patch value is not
  * detected for a component/directive instance then it will throw an error (all components and
  * directives should be automatically monkey-patched by ivy).
+ *
+ * @param target Component, Directive or DOM Node.
  */
 export function getContext(target: any): LContext|null {
   let mpValue = readPatchedData(target);
@@ -54,7 +58,7 @@ export function getContext(target: any): LContext|null {
         if (nodeIndex == -1) {
           throw new Error('The provided directive was not found in the application');
         }
-        directives = discoverDirectives(nodeIndex, lViewData, false);
+        directives = getDirectivesAtNodeIndex(nodeIndex, lViewData, false);
       } else {
         nodeIndex = findViaNativeElement(lViewData, target as RElement);
         if (nodeIndex == -1) {
@@ -132,7 +136,8 @@ export function getContext(target: any): LContext|null {
 function createLContext(lViewData: LViewData, nodeIndex: number, native: RElement): LContext {
   return {
     lViewData,
-    nodeIndex: nodeIndex, native,
+    nodeIndex,
+    native,
     component: undefined,
     directives: undefined,
     localRefs: undefined,
@@ -271,15 +276,22 @@ function assertDomElement(element: any) {
  * @param lViewData The target view data
  * @param includeComponents Whether or not to include components in returned directives
  */
-export function discoverDirectives(
+export function getDirectivesAtNodeIndex(
     nodeIndex: number, lViewData: LViewData, includeComponents: boolean): any[]|null {
   const tNode = lViewData[TVIEW].data[nodeIndex] as TNode;
   let directiveStartIndex = getDirectiveStartIndex(tNode);
+  if (directiveStartIndex == 0) return EMPTY_ARRAY;
   const directiveEndIndex = getDirectiveEndIndex(tNode, directiveStartIndex);
   if (!includeComponents && tNode.flags & TNodeFlags.isComponent) directiveStartIndex++;
   return lViewData.slice(directiveStartIndex, directiveEndIndex);
 }
 
+export function getComponentAtNodeIndex(nodeIndex: number, lViewData: LViewData): {}|null {
+  const tNode = lViewData[TVIEW].data[nodeIndex] as TNode;
+  let directiveStartIndex = getDirectiveStartIndex(tNode);
+  return tNode.flags & TNodeFlags.isComponent ? lViewData[directiveStartIndex] : null;
+}
+
 /**
  * Returns a map of local references (local reference name => element or directive instance) that
  * exist on a given element.

packages/core/src/render3/debug.ts

@@ -11,11 +11,12 @@ import {Renderer2, RendererType2} from '../render/api';
 import {DebugContext} from '../view';
 import {DebugRenderer2, DebugRendererFactory2} from '../view/services';
 
-import {getHostComponent, getInjector, getLocalRefs, loadContext} from './discovery_utils';
+import {getComponent, getInjector, getLocalRefs, loadContext} from './discovery_utils';
 import {DirectiveDef} from './interfaces/definition';
 import {TNode, TNodeFlags} from './interfaces/node';
 import {TVIEW} from './interfaces/view';
 
+
 /**
  * Adapts the DebugRendererFactory2 to create a DebugRenderer2 specific for IVY.
  *
@@ -43,7 +44,7 @@ class Render3DebugContext implements DebugContext {
 
   get injector(): Injector { return getInjector(this._nativeNode); }
 
-  get component(): any { return getHostComponent(this._nativeNode); }
+  get component(): any { return getComponent(this._nativeNode); }
 
   get providerTokens(): any[] {
     const lDebugCtx = loadContext(this._nativeNode);