refactor(compiler): rename R3ProviderExpression and associated helpers

This interface will be used in other situations so this change renames it to be more general as `MaybeForwardRefExpression`.

Author: petebacondarwin

packages/compiler-cli/linker/src/file_linker/partial_linkers/partial_injectable_linker_1.ts

@@ -5,7 +5,7 @@
  * 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 {compileInjectable, ConstantPool, createR3ProviderExpression, R3DeclareInjectableMetadata, R3InjectableMetadata, R3PartialDeclaration} from '@angular/compiler';
+import {compileInjectable, ConstantPool, createMayBeForwardRefExpression, R3DeclareInjectableMetadata, R3InjectableMetadata, R3PartialDeclaration} from '@angular/compiler';
 import * as o from '@angular/compiler/src/output/output_ast';
 
 import {AstObject} from '../../ast/ast_value';
@@ -45,7 +45,7 @@ export function toR3InjectableMeta<TExpression>(
     internalType: typeExpr.getOpaque(),
     typeArgumentCount: 0,
     providedIn: metaObj.has('providedIn') ? extractForwardRef(metaObj.getValue('providedIn')) :
-                                            createR3ProviderExpression(o.literal(null), false),
+                                            createMayBeForwardRefExpression(o.literal(null), false),
   };
 
   if (metaObj.has('useClass')) {

packages/compiler-cli/linker/src/file_linker/partial_linkers/util.ts

@@ -5,7 +5,7 @@
  * 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 {createR3ProviderExpression, R3DeclareDependencyMetadata, R3DependencyMetadata, R3ProviderExpression, R3Reference} from '@angular/compiler';
+import {createMayBeForwardRefExpression, MaybeForwardRefExpression, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference} from '@angular/compiler';
 import * as o from '@angular/compiler/src/output/output_ast';
 
 import {AstObject, AstValue} from '../../ast/ast_value';
@@ -67,9 +67,9 @@ export function getDependency<TExpression>(
  * If there is no forwardRef call expression then we just return the opaque type.
  */
 export function extractForwardRef<TExpression>(expr: AstValue<unknown, TExpression>):
-    R3ProviderExpression<o.WrappedNodeExpr<TExpression>> {
+    MaybeForwardRefExpression<o.WrappedNodeExpr<TExpression>> {
   if (!expr.isCallExpression()) {
-    return createR3ProviderExpression(expr.getOpaque(), /* isForwardRef */ false);
+    return createMayBeForwardRefExpression(expr.getOpaque(), /* isForwardRef */ false);
   }
 
   const callee = expr.getCallee();
@@ -91,5 +91,5 @@ export function extractForwardRef<TExpression>(expr: AstValue<unknown, TExpressi
         wrapperFn, 'Unsupported `forwardRef(fn)` call, expected its argument to be a function');
   }
 
-  return createR3ProviderExpression(wrapperFn.getFunctionReturnValue().getOpaque(), true);
+  return createMayBeForwardRefExpression(wrapperFn.getFunctionReturnValue().getOpaque(), true);
 }

packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {compileClassMetadata, CompileClassMetadataFn, compileDeclareClassMetadata, compileDeclareInjectableFromMetadata, compileInjectable, createR3ProviderExpression, Expression, FactoryTarget, LiteralExpr, R3ClassMetadata, R3CompiledExpression, R3DependencyMetadata, R3InjectableMetadata, R3ProviderExpression, Statement, WrappedNodeExpr} from '@angular/compiler';
+import {compileClassMetadata, CompileClassMetadataFn, compileDeclareClassMetadata, compileDeclareInjectableFromMetadata, compileInjectable, createMayBeForwardRefExpression, FactoryTarget, LiteralExpr, MaybeForwardRefExpression, R3ClassMetadata, R3CompiledExpression, R3DependencyMetadata, R3InjectableMetadata, WrappedNodeExpr} from '@angular/compiler';
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
@@ -162,7 +162,7 @@ function extractInjectableMetadata(
       type,
       typeArgumentCount,
       internalType,
-      providedIn: createR3ProviderExpression(new LiteralExpr(null), false),
+      providedIn: createMayBeForwardRefExpression(new LiteralExpr(null), false),
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
@@ -180,7 +180,7 @@ function extractInjectableMetadata(
 
     const providedIn = meta.has('providedIn') ?
         getProviderExpression(meta.get('providedIn')!, reflector) :
-        createR3ProviderExpression(new LiteralExpr(null), false);
+        createMayBeForwardRefExpression(new LiteralExpr(null), false);
 
     let deps: R3DependencyMetadata[]|undefined = undefined;
     if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
@@ -220,9 +220,9 @@ function extractInjectableMetadata(
  * object to indicate whether the value needed unwrapping.
  */
 function getProviderExpression(
-    expression: ts.Expression, reflector: ReflectionHost): R3ProviderExpression {
+    expression: ts.Expression, reflector: ReflectionHost): MaybeForwardRefExpression {
   const forwardRefValue = tryUnwrapForwardRef(expression, reflector);
-  return createR3ProviderExpression(
+  return createMayBeForwardRefExpression(
       new WrappedNodeExpr(forwardRefValue ?? expression), forwardRefValue !== null);
 }
 

packages/compiler/src/compiler.ts

@@ -103,7 +103,7 @@ export {compileNgModule, R3NgModuleMetadata} from './render3/r3_module_compiler'
 export {compileInjector, R3InjectorMetadata} from './render3/r3_injector_compiler';
 export {compilePipeFromMetadata, R3PipeMetadata} from './render3/r3_pipe_compiler';
 export {makeBindingParser, ParsedTemplate, parseTemplate, ParseTemplateOptions} from './render3/view/template';
-export {R3CompiledExpression, R3Reference, devOnlyGuardedExpression, getSafePropertyAccessString} from './render3/util';
+export {MaybeForwardRefExpression, R3CompiledExpression, R3Reference, createMayBeForwardRefExpression, devOnlyGuardedExpression, getSafePropertyAccessString} from './render3/util';
 export {compileComponentFromMetadata, compileDirectiveFromMetadata, parseHostBindings, ParsedHostBindings, verifyHostBindings} from './render3/view/compiler';
 export {compileDeclareClassMetadata} from './render3/partial/class_metadata';
 export {compileDeclareComponentFromMetadata, DeclareComponentTemplateInfo} from './render3/partial/component';

packages/compiler/src/injectable_compiler_2.ts

@@ -7,59 +7,24 @@
  */
 
 import * as o from './output/output_ast';
-import {generateForwardRef} from './render3/partial/util';
 import {compileFactoryFunction, FactoryTarget, R3DependencyMetadata, R3FactoryDelegateType, R3FactoryMetadata} from './render3/r3_factory';
 import {Identifiers} from './render3/r3_identifiers';
-import {R3CompiledExpression, R3Reference, typeWithParameters} from './render3/util';
+import {generateForwardRef, MaybeForwardRefExpression, R3CompiledExpression, R3Reference, typeWithParameters} from './render3/util';
 import {DefinitionMap} from './render3/view/util';
 
 export interface R3InjectableMetadata {
   name: string;
   type: R3Reference;
   internalType: o.Expression;
   typeArgumentCount: number;
-  providedIn: R3ProviderExpression;
-  useClass?: R3ProviderExpression;
+  providedIn: MaybeForwardRefExpression;
+  useClass?: MaybeForwardRefExpression;
   useFactory?: o.Expression;
-  useExisting?: R3ProviderExpression;
-  useValue?: R3ProviderExpression;
+  useExisting?: MaybeForwardRefExpression;
+  useValue?: MaybeForwardRefExpression;
   deps?: R3DependencyMetadata[];
 }
 
-/**
- * An expression used when instantiating an injectable.
- *
- * This is the type of the `useClass`, `useExisting` and `useValue` properties of
- * `R3InjectableMetadata` since those can refer to types that may eagerly reference types that have
- * not yet been defined.
- */
-export interface R3ProviderExpression<T extends o.Expression = o.Expression> {
-  /**
-   * The expression that is used to instantiate the Injectable.
-   */
-  expression: T;
-  /**
-   * If true, then the `expression` contains a reference to something that has not yet been
-   * defined.
-   *
-   * This means that the expression must not be eagerly evaluated. Instead it must be wrapped in a
-   * function closure that will be evaluated lazily to allow the definition of the expression to be
-   * evaluated first.
-   *
-   * In some cases the expression will naturally be placed inside such a function closure, such as
-   * in a fully compiled factory function. In those case nothing more needs to be done.
-   *
-   * But in other cases, such as partial-compilation the expression will be located in top level
-   * code so will need to be wrapped in a function that is passed to a `forwardRef()` call.
-   */
-  isForwardRef: boolean;
-}
-
-export function createR3ProviderExpression<T extends o.Expression>(
-    expression: T, isForwardRef: boolean): R3ProviderExpression<T> {
-  return {expression, isForwardRef};
-}
-
 export function compileInjectable(
     meta: R3InjectableMetadata, resolveForwardRefs: boolean): R3CompiledExpression {
   let result: {expression: o.Expression, statements: o.Statement[]}|null = null;

packages/compiler/src/jit_compiler_facade.ts

@@ -10,7 +10,7 @@
 import {CompilerFacade, CoreEnvironment, ExportedCompilerFacade, OpaqueValue, R3ComponentMetadataFacade, R3DeclareComponentFacade, R3DeclareDependencyMetadataFacade, R3DeclareDirectiveFacade, R3DeclareFactoryFacade, R3DeclareInjectableFacade, R3DeclareInjectorFacade, R3DeclareNgModuleFacade, R3DeclarePipeFacade, R3DeclareQueryMetadataFacade, R3DeclareUsedDirectiveFacade, R3DependencyMetadataFacade, R3DirectiveMetadataFacade, R3FactoryDefMetadataFacade, R3InjectableMetadataFacade, R3InjectorMetadataFacade, R3NgModuleMetadataFacade, R3PipeMetadataFacade, R3QueryMetadataFacade, StringMap, StringMapWithRename} from './compiler_facade_interface';
 import {ConstantPool} from './constant_pool';
 import {ChangeDetectionStrategy, HostBinding, HostListener, Input, Output, ViewEncapsulation} from './core';
-import {compileInjectable, createR3ProviderExpression, R3ProviderExpression} from './injectable_compiler_2';
+import {compileInjectable} from './injectable_compiler_2';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './ml_parser/interpolation_config';
 import {DeclareVarStmt, Expression, literal, LiteralExpr, Statement, StmtModifier, WrappedNodeExpr} from './output/output_ast';
 import {JitEvaluator} from './output/output_jit';
@@ -20,7 +20,7 @@ import {compileInjector, R3InjectorMetadata} from './render3/r3_injector_compile
 import {R3JitReflector} from './render3/r3_jit';
 import {compileNgModule, compileNgModuleDeclarationExpression, R3NgModuleMetadata} from './render3/r3_module_compiler';
 import {compilePipeFromMetadata, R3PipeMetadata} from './render3/r3_pipe_compiler';
-import {getSafePropertyAccessString, wrapReference} from './render3/util';
+import {createMayBeForwardRefExpression, getSafePropertyAccessString, MaybeForwardRefExpression, wrapReference} from './render3/util';
 import {DeclarationListEmitMode, R3ComponentMetadata, R3DirectiveMetadata, R3HostMetadata, R3QueryMetadata, R3UsedDirectiveMetadata} from './render3/view/api';
 import {compileComponentFromMetadata, compileDirectiveFromMetadata, ParsedHostBindings, parseHostBindings, verifyHostBindings} from './render3/view/compiler';
 import {makeBindingParser, parseTemplate} from './render3/view/template';
@@ -478,9 +478,11 @@ type R3DirectiveMetadataFacadeNoPropAndWhitespace =
  * a `forwardRef()` - either by the application developer or during partial-compilation. Thus we can
  * set `isForwardRef` to `false`.
  */
-function convertToProviderExpression(obj: any, property: string): R3ProviderExpression|undefined {
+function convertToProviderExpression(obj: any, property: string): MaybeForwardRefExpression|
+    undefined {
   if (obj.hasOwnProperty(property)) {
-    return createR3ProviderExpression(new WrappedNodeExpr(obj[property]), /* isForwardRef */ false);
+    return createMayBeForwardRefExpression(
+        new WrappedNodeExpr(obj[property]), /* isForwardRef */ false);
   } else {
     return undefined;
   }
@@ -494,12 +496,12 @@ function wrapExpression(obj: any, property: string): WrappedNodeExpr<any>|undefi
   }
 }
 
-function computeProvidedIn(providedIn: Function|string|null|undefined): R3ProviderExpression {
+function computeProvidedIn(providedIn: Function|string|null|undefined): MaybeForwardRefExpression {
   const expression = (providedIn == null || typeof providedIn === 'string') ?
       new LiteralExpr(providedIn ?? null) :
       new WrappedNodeExpr(providedIn);
   // See `convertToProviderExpression()` for why `isForwardRef` is false.
-  return createR3ProviderExpression(expression, /* isForwardRef */ false);
+  return createMayBeForwardRefExpression(expression, /* isForwardRef */ false);
 }
 
 function convertR3DependencyMetadataArray(facades: R3DependencyMetadataFacade[]|null|

packages/compiler/src/render3/partial/component.ts

@@ -10,15 +10,15 @@ import {DEFAULT_INTERPOLATION_CONFIG} from '../../ml_parser/interpolation_config
 import * as o from '../../output/output_ast';
 import {ParseLocation, ParseSourceFile, ParseSourceSpan} from '../../parse_util';
 import {Identifiers as R3} from '../r3_identifiers';
-import {R3CompiledExpression} from '../util';
+import {generateForwardRef, R3CompiledExpression} from '../util';
 import {DeclarationListEmitMode, R3ComponentMetadata, R3UsedDirectiveMetadata} from '../view/api';
 import {createComponentType} from '../view/compiler';
 import {ParsedTemplate} from '../view/template';
 import {DefinitionMap} from '../view/util';
 
 import {R3DeclareComponentMetadata, R3DeclareUsedDirectiveMetadata} from './api';
 import {createDirectiveDefinitionMap} from './directive';
-import {generateForwardRef, toOptionalLiteralArray} from './util';
+import {toOptionalLiteralArray} from './util';
 
 export interface DeclareComponentTemplateInfo {
   /**

packages/compiler/src/render3/partial/injectable.ts

@@ -5,14 +5,14 @@
  * 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 {createInjectableType, R3InjectableMetadata, R3ProviderExpression} from '../../injectable_compiler_2';
+import {createInjectableType, R3InjectableMetadata} from '../../injectable_compiler_2';
 import * as o from '../../output/output_ast';
 import {Identifiers as R3} from '../r3_identifiers';
-import {R3CompiledExpression} from '../util';
+import {convertFromMaybeForwardRefExpression, R3CompiledExpression} from '../util';
 import {DefinitionMap} from '../view/util';
 
 import {R3DeclareInjectableMetadata} from './api';
-import {compileDependency, generateForwardRef} from './util';
+import {compileDependency} from './util';
 
 /**
  * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
@@ -50,20 +50,20 @@ export function createInjectableDefinitionMap(meta: R3InjectableMetadata):
 
   // Only generate providedIn property if it has a non-null value
   if (meta.providedIn !== undefined) {
-    const providedIn = convertFromProviderExpression(meta.providedIn);
+    const providedIn = convertFromMaybeForwardRefExpression(meta.providedIn);
     if ((providedIn as o.LiteralExpr).value !== null) {
       definitionMap.set('providedIn', providedIn);
     }
   }
 
   if (meta.useClass !== undefined) {
-    definitionMap.set('useClass', convertFromProviderExpression(meta.useClass));
+    definitionMap.set('useClass', convertFromMaybeForwardRefExpression(meta.useClass));
   }
   if (meta.useExisting !== undefined) {
-    definitionMap.set('useExisting', convertFromProviderExpression(meta.useExisting));
+    definitionMap.set('useExisting', convertFromMaybeForwardRefExpression(meta.useExisting));
   }
   if (meta.useValue !== undefined) {
-    definitionMap.set('useValue', convertFromProviderExpression(meta.useValue));
+    definitionMap.set('useValue', convertFromMaybeForwardRefExpression(meta.useValue));
   }
   // Factories do not contain `ForwardRef`s since any types are already wrapped in a function call
   // so the types will not be eagerly evaluated. Therefore we do not need to process this expression
@@ -78,26 +78,3 @@ export function createInjectableDefinitionMap(meta: R3InjectableMetadata):
 
   return definitionMap;
 }
-
-/**
- * Convert an `R3ProviderExpression` to an `Expression`, possibly wrapping its expression in a
- * `forwardRef()` call.
- *
- * If `R3ProviderExpression.isForwardRef` is true then the expression was originally wrapped in a
- * `forwardRef()` call to prevent the value from being eagerly evaluated in the code.
- *
- * Normally, the linker will statically process the code, putting the `expression` inside a factory
- * function so the `forwardRef()` wrapper is not evaluated before it has been defined. But if the
- * partial declaration is evaluated by the JIT compiler the `forwardRef()` call is still needed to
- * prevent eager evaluation of the `expression`.
- *
- * So in partial declarations, expressions that could be forward-refs are wrapped in `forwardRef()`
- * calls, and this is then unwrapped in the linker as necessary.
- *
- * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
- * `packages/compiler/src/jit_compiler_facade.ts` for more information.
- */
-function convertFromProviderExpression({expression, isForwardRef}: R3ProviderExpression):
-    o.Expression {
-  return isForwardRef ? generateForwardRef(expression) : expression;
-}

packages/compiler/src/render3/partial/util.ts

@@ -7,7 +7,6 @@
  */
 import * as o from '../../output/output_ast';
 import {R3DependencyMetadata} from '../r3_factory';
-import {Identifiers} from '../r3_identifiers';
 import {DefinitionMap} from '../view/util';
 import {R3DeclareDependencyMetadata} from './api';
 
@@ -84,14 +83,3 @@ export function compileDependency(dep: R3DependencyMetadata): o.LiteralMapExpr {
   }
   return depMeta.toLiteralMap();
 }
-
-/**
- * Generate an expression that has the given `expr` wrapped in the following form:
- *
- * ```
- * forwardRef(() => expr)
- * ```
- */
-export function generateForwardRef(expr: o.Expression): o.Expression {
-  return o.importExpr(Identifiers.forwardRef).callFn([o.fn([], [new o.ReturnStatement(expr)])]);
-}