static-injector 1.0.9 → 2.0.0

package/transform/compiler/src/output/output_ast.js

@@ -7,19 +7,20 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.FunctionExpr = exports.FnParam = exports.CastExpr = exports.AssertNotNull = exports.NotExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.PlaceholderPiece = exports.LiteralPiece = exports.MessagePiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.InvokeMethodExpr = exports.BuiltinMethod = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.BuiltinVar = exports.Expression = exports.areAllEquivalent = exports.nullSafeIsEquivalent = exports.BinaryOperator = exports.UnaryOperator = exports.NONE_TYPE = exports.FUNCTION_TYPE = exports.STRING_TYPE = exports.NUMBER_TYPE = exports.INT_TYPE = exports.BOOL_TYPE = exports.INFERRED_TYPE = exports.DYNAMIC_TYPE = exports.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
-exports.isNull = exports.literal = exports.ifStmt = exports.fn = exports.assertNotNull = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.expressionType = exports.importExpr = exports.variable = exports.IfStmt = exports.ClassStmt = exports.ClassGetter = exports.ClassMethod = exports.ClassField = exports.AbstractClassPart = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = exports.LeadingComment = exports.StmtModifier = exports.TYPED_NULL_EXPR = exports.NULL_EXPR = exports.CATCH_STACK_VAR = exports.CATCH_ERROR_VAR = exports.SUPER_EXPR = exports.THIS_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = void 0;
+exports.LeadingComment = exports.StmtModifier = exports.TYPED_NULL_EXPR = exports.NULL_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = exports.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.FunctionExpr = exports.FnParam = exports.NotExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.LiteralPiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.Expression = exports.areAllEquivalent = exports.nullSafeIsEquivalent = exports.BinaryOperator = exports.UnaryOperator = exports.NONE_TYPE = exports.FUNCTION_TYPE = exports.STRING_TYPE = exports.NUMBER_TYPE = exports.INT_TYPE = exports.BOOL_TYPE = exports.INFERRED_TYPE = exports.DYNAMIC_TYPE = exports.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
+exports.isNull = exports.literal = exports.ifStmt = exports.fn = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.expressionType = exports.importType = exports.importExpr = exports.variable = exports.jsDocComment = exports.leadingComment = exports.IfStmt = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = void 0;
 //// Types
 var TypeModifier;
 (function (TypeModifier) {
-    TypeModifier[TypeModifier["Const"] = 0] = "Const";
+    TypeModifier[TypeModifier["None"] = 0] = "None";
+    TypeModifier[TypeModifier["Const"] = 1] = "Const";
 })(TypeModifier = exports.TypeModifier || (exports.TypeModifier = {}));
 class Type {
-    constructor(modifiers = []) {
+    constructor(modifiers = TypeModifier.None) {
         this.modifiers = modifiers;
     }
     hasModifier(modifier) {
-        return this.modifiers.indexOf(modifier) !== -1;
+        return (this.modifiers & modifier) !== 0;
     }
 }
 exports.Type = Type;
@@ -140,8 +141,8 @@ class Expression {
     prop(name, sourceSpan) {
         return new ReadPropExpr(this, name, null, sourceSpan);
     }
-    callMethod(name, params, sourceSpan) {
-        return new InvokeMethodExpr(this, name, params, null, sourceSpan);
+    key(index, type, sourceSpan) {
+        return new ReadKeyExpr(this, index, type, sourceSpan);
     }
     callFn(params, sourceSpan, pure) {
         return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
@@ -151,29 +152,13 @@ class Expression {
     }
 }
 exports.Expression = Expression;
-var BuiltinVar;
-(function (BuiltinVar) {
-    BuiltinVar[BuiltinVar["This"] = 0] = "This";
-    BuiltinVar[BuiltinVar["Super"] = 1] = "Super";
-    BuiltinVar[BuiltinVar["CatchError"] = 2] = "CatchError";
-    BuiltinVar[BuiltinVar["CatchStack"] = 3] = "CatchStack";
-})(BuiltinVar = exports.BuiltinVar || (exports.BuiltinVar = {}));
 class ReadVarExpr extends Expression {
     constructor(name, type, sourceSpan) {
         super(type, sourceSpan);
-        if (typeof name === 'string') {
-            this.name = name;
-            this.builtin = null;
-        }
-        else {
-            this.name = null;
-            this.builtin = name;
-        }
+        this.name = name;
     }
     isEquivalent(e) {
-        return (e instanceof ReadVarExpr &&
-            this.name === e.name &&
-            this.builtin === e.builtin);
+        return e instanceof ReadVarExpr && this.name === e.name;
     }
     isConstant() {
         return false;
@@ -182,9 +167,6 @@ class ReadVarExpr extends Expression {
         return visitor.visitReadVarExpr(this, context);
     }
     set(value) {
-        if (!this.name) {
-            throw new Error(`Built in variable ${this.builtin} can not be assigned to.`);
-        }
         return new WriteVarExpr(this.name, value, null, this.sourceSpan);
     }
 }
@@ -242,7 +224,7 @@ class WriteVarExpr extends Expression {
         return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
     }
     toConstDecl() {
-        return this.toDeclStmt(exports.INFERRED_TYPE, [StmtModifier.Final]);
+        return this.toDeclStmt(exports.INFERRED_TYPE, StmtModifier.Final);
     }
 }
 exports.WriteVarExpr = WriteVarExpr;
@@ -288,41 +270,6 @@ class WritePropExpr extends Expression {
     }
 }
 exports.WritePropExpr = WritePropExpr;
-var BuiltinMethod;
-(function (BuiltinMethod) {
-    BuiltinMethod[BuiltinMethod["ConcatArray"] = 0] = "ConcatArray";
-    BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable";
-    BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind";
-})(BuiltinMethod = exports.BuiltinMethod || (exports.BuiltinMethod = {}));
-class InvokeMethodExpr extends Expression {
-    constructor(receiver, method, args, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.receiver = receiver;
-        this.args = args;
-        if (typeof method === 'string') {
-            this.name = method;
-            this.builtin = null;
-        }
-        else {
-            this.name = null;
-            this.builtin = method;
-        }
-    }
-    isEquivalent(e) {
-        return (e instanceof InvokeMethodExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.name === e.name &&
-            this.builtin === e.builtin &&
-            areAllEquivalent(this.args, e.args));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitInvokeMethodExpr(this, context);
-    }
-}
-exports.InvokeMethodExpr = InvokeMethodExpr;
 class InvokeFunctionExpr extends Expression {
     constructor(fn, args, type, sourceSpan, pure = false) {
         super(type, sourceSpan);
@@ -402,23 +349,47 @@ class TemplateLiteralElement {
     }
 }
 exports.TemplateLiteralElement = TemplateLiteralElement;
-class MessagePiece {
+class LiteralPiece {
     constructor(text, sourceSpan) {
         this.text = text;
         this.sourceSpan = sourceSpan;
     }
 }
-exports.MessagePiece = MessagePiece;
-class LiteralPiece extends MessagePiece {
-}
 exports.LiteralPiece = LiteralPiece;
-class PlaceholderPiece extends MessagePiece {
-}
-exports.PlaceholderPiece = PlaceholderPiece;
 const escapeSlashes = (str) => str.replace(/\\/g, '\\\\');
 const escapeStartingColon = (str) => str.replace(/^:/, '\\:');
 const escapeColons = (str) => str.replace(/:/g, '\\:');
 const escapeForTemplateLiteral = (str) => str.replace(/`/g, '\\`').replace(/\${/g, '$\\{');
+/**
+ * Creates a `{cooked, raw}` object from the `metaBlock` and `messagePart`.
+ *
+ * The `raw` text must have various character sequences escaped:
+ * * "\" would otherwise indicate that the next character is a control character.
+ * * "`" and "${" are template string control sequences that would otherwise prematurely indicate
+ *   the end of a message part.
+ * * ":" inside a metablock would prematurely indicate the end of the metablock.
+ * * ":" at the start of a messagePart with no metablock would erroneously indicate the start of a
+ *   metablock.
+ *
+ * @param metaBlock Any metadata that should be prepended to the string
+ * @param messagePart The message part of the string
+ */
+function createCookedRawString(metaBlock, messagePart, range) {
+    if (metaBlock === '') {
+        return {
+            cooked: messagePart,
+            raw: escapeForTemplateLiteral(escapeStartingColon(escapeSlashes(messagePart))),
+            range,
+        };
+    }
+    else {
+        return {
+            cooked: `:${metaBlock}:${messagePart}`,
+            raw: escapeForTemplateLiteral(`:${escapeColons(escapeSlashes(metaBlock))}:${escapeSlashes(messagePart)}`),
+            range,
+        };
+    }
+}
 class ExternalExpr extends Expression {
     constructor(value, type, typeParams = null, sourceSpan) {
         super(type, sourceSpan);
@@ -484,38 +455,6 @@ class NotExpr extends Expression {
     }
 }
 exports.NotExpr = NotExpr;
-class AssertNotNull extends Expression {
-    constructor(condition, sourceSpan) {
-        super(condition.type, sourceSpan);
-        this.condition = condition;
-    }
-    isEquivalent(e) {
-        return (e instanceof AssertNotNull && this.condition.isEquivalent(e.condition));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitAssertNotNullExpr(this, context);
-    }
-}
-exports.AssertNotNull = AssertNotNull;
-class CastExpr extends Expression {
-    constructor(value, type, sourceSpan) {
-        super(type, sourceSpan);
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return e instanceof CastExpr && this.value.isEquivalent(e.value);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitCastExpr(this, context);
-    }
-}
-exports.CastExpr = CastExpr;
 class FnParam {
     constructor(name, type = null) {
         this.name = name;
@@ -698,19 +637,16 @@ class CommaExpr extends Expression {
     }
 }
 exports.CommaExpr = CommaExpr;
-exports.THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);
-exports.SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super, null, null);
-exports.CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError, null, null);
-exports.CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack, null, null);
 exports.NULL_EXPR = new LiteralExpr(null, null, null);
 exports.TYPED_NULL_EXPR = new LiteralExpr(null, exports.INFERRED_TYPE, null);
 //// Statements
 var StmtModifier;
 (function (StmtModifier) {
-    StmtModifier[StmtModifier["Final"] = 0] = "Final";
-    StmtModifier[StmtModifier["Private"] = 1] = "Private";
-    StmtModifier[StmtModifier["Exported"] = 2] = "Exported";
-    StmtModifier[StmtModifier["Static"] = 3] = "Static";
+    StmtModifier[StmtModifier["None"] = 0] = "None";
+    StmtModifier[StmtModifier["Final"] = 1] = "Final";
+    StmtModifier[StmtModifier["Private"] = 2] = "Private";
+    StmtModifier[StmtModifier["Exported"] = 4] = "Exported";
+    StmtModifier[StmtModifier["Static"] = 8] = "Static";
 })(StmtModifier = exports.StmtModifier || (exports.StmtModifier = {}));
 class LeadingComment {
     constructor(text, multiline, trailingNewline) {
@@ -734,13 +670,13 @@ class JSDocComment extends LeadingComment {
 }
 exports.JSDocComment = JSDocComment;
 class Statement {
-    constructor(modifiers = [], sourceSpan = null, leadingComments) {
+    constructor(modifiers = StmtModifier.None, sourceSpan = null, leadingComments) {
         this.modifiers = modifiers;
         this.sourceSpan = sourceSpan;
         this.leadingComments = leadingComments;
     }
     hasModifier(modifier) {
-        return this.modifiers.indexOf(modifier) !== -1;
+        return (this.modifiers & modifier) !== 0;
     }
     addLeadingComment(leadingComment) {
         var _a;
@@ -788,7 +724,7 @@ class DeclareFunctionStmt extends Statement {
 exports.DeclareFunctionStmt = DeclareFunctionStmt;
 class ExpressionStatement extends Statement {
     constructor(expr, sourceSpan, leadingComments) {
-        super([], sourceSpan, leadingComments);
+        super(StmtModifier.None, sourceSpan, leadingComments);
         this.expr = expr;
     }
     isEquivalent(stmt) {
@@ -801,7 +737,7 @@ class ExpressionStatement extends Statement {
 exports.ExpressionStatement = ExpressionStatement;
 class ReturnStatement extends Statement {
     constructor(value, sourceSpan = null, leadingComments) {
-        super([], sourceSpan, leadingComments);
+        super(StmtModifier.None, sourceSpan, leadingComments);
         this.value = value;
     }
     isEquivalent(stmt) {
@@ -812,77 +748,9 @@ class ReturnStatement extends Statement {
     }
 }
 exports.ReturnStatement = ReturnStatement;
-class AbstractClassPart {
-    constructor(type = null, modifiers = []) {
-        this.type = type;
-        this.modifiers = modifiers;
-    }
-    hasModifier(modifier) {
-        return this.modifiers.indexOf(modifier) !== -1;
-    }
-}
-exports.AbstractClassPart = AbstractClassPart;
-class ClassField extends AbstractClassPart {
-    constructor(name, type, modifiers, initializer) {
-        super(type, modifiers);
-        this.name = name;
-        this.initializer = initializer;
-    }
-    isEquivalent(f) {
-        return this.name === f.name;
-    }
-}
-exports.ClassField = ClassField;
-class ClassMethod extends AbstractClassPart {
-    constructor(name, params, body, type, modifiers) {
-        super(type, modifiers);
-        this.name = name;
-        this.params = params;
-        this.body = body;
-    }
-    isEquivalent(m) {
-        return this.name === m.name && areAllEquivalent(this.body, m.body);
-    }
-}
-exports.ClassMethod = ClassMethod;
-class ClassGetter extends AbstractClassPart {
-    constructor(name, body, type, modifiers) {
-        super(type, modifiers);
-        this.name = name;
-        this.body = body;
-    }
-    isEquivalent(m) {
-        return this.name === m.name && areAllEquivalent(this.body, m.body);
-    }
-}
-exports.ClassGetter = ClassGetter;
-class ClassStmt extends Statement {
-    constructor(name, parent, fields, getters, constructorMethod, methods, modifiers, sourceSpan, leadingComments) {
-        super(modifiers, sourceSpan, leadingComments);
-        this.name = name;
-        this.parent = parent;
-        this.fields = fields;
-        this.getters = getters;
-        this.constructorMethod = constructorMethod;
-        this.methods = methods;
-    }
-    isEquivalent(stmt) {
-        return (stmt instanceof ClassStmt &&
-            this.name === stmt.name &&
-            nullSafeIsEquivalent(this.parent, stmt.parent) &&
-            areAllEquivalent(this.fields, stmt.fields) &&
-            areAllEquivalent(this.getters, stmt.getters) &&
-            this.constructorMethod.isEquivalent(stmt.constructorMethod) &&
-            areAllEquivalent(this.methods, stmt.methods));
-    }
-    visitStatement(visitor, context) {
-        return visitor.visitDeclareClassStmt(this, context);
-    }
-}
-exports.ClassStmt = ClassStmt;
 class IfStmt extends Statement {
     constructor(condition, trueCase, falseCase = [], sourceSpan, leadingComments) {
-        super([], sourceSpan, leadingComments);
+        super(StmtModifier.None, sourceSpan, leadingComments);
         this.condition = condition;
         this.trueCase = trueCase;
         this.falseCase = falseCase;
@@ -898,6 +766,14 @@ class IfStmt extends Statement {
     }
 }
 exports.IfStmt = IfStmt;
+function leadingComment(text, multiline = false, trailingNewline = true) {
+    return new LeadingComment(text, multiline, trailingNewline);
+}
+exports.leadingComment = leadingComment;
+function jsDocComment(tags = []) {
+    return new JSDocComment(tags);
+}
+exports.jsDocComment = jsDocComment;
 function variable(name, type, sourceSpan) {
     return new ReadVarExpr(name, type, sourceSpan);
 }
@@ -906,6 +782,12 @@ function importExpr(id, typeParams = null, sourceSpan) {
     return new ExternalExpr(id, null, typeParams, sourceSpan);
 }
 exports.importExpr = importExpr;
+function importType(id, typeParams, typeModifiers) {
+    return id != null
+        ? expressionType(importExpr(id, typeParams, null), typeModifiers)
+        : null;
+}
+exports.importType = importType;
 function expressionType(expr, typeModifiers, typeParams) {
     return new ExpressionType(expr, typeModifiers, typeParams);
 }
@@ -930,10 +812,6 @@ function not(expr, sourceSpan) {
     return new NotExpr(expr, sourceSpan);
 }
 exports.not = not;
-function assertNotNull(expr, sourceSpan) {
-    return new AssertNotNull(expr, sourceSpan);
-}
-exports.assertNotNull = assertNotNull;
 function fn(params, body, type, sourceSpan, name) {
     return new FunctionExpr(params, body, type, sourceSpan, name);
 }

package/transform/compiler/src/render3/r3_factory.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -137,7 +141,7 @@ function createFactoryType(meta) {
         ? createCtorDepsType(meta.deps)
         : outputAst.NONE_TYPE;
     return outputAst.expressionType(outputAst.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
-        util_1.typeWithParameters(meta.type.type, meta.typeArgumentCount),
+        (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
         ctorDepsType,
     ]));
 }
@@ -154,14 +158,14 @@ function compileInjectDependency(dep, target, index) {
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
-        const flags = 0 /* Default */ |
-            (dep.self ? 2 /* Self */ : 0) |
-            (dep.skipSelf ? 4 /* SkipSelf */ : 0) |
-            (dep.optional ? 8 /* Optional */ : 0);
+        const flags = 0 /* InjectFlags.Default */ |
+            (dep.self ? 2 /* InjectFlags.Self */ : 0) |
+            (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) |
+            (dep.optional ? 8 /* InjectFlags.Optional */ : 0);
         // If this dependency is optional or otherwise has non-default flags, then additional
         // parameters describing how to inject the dependency must be passed to the inject function
         // that's being used.
-        let flagsParam = flags !== 0 /* Default */ || dep.optional
+        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional
             ? outputAst.literal(flags)
             : null;
         // Build up the arguments to the injectFn call.

package/transform/compiler/src/render3/util.d.ts

@@ -19,3 +19,67 @@ export interface R3CompiledExpression {
     type: o.Type;
     statements: o.Statement[];
 }
+/**
+ * Describes an expression that may have been wrapped in a `forwardRef()` guard.
+ *
+ * This is used when describing expressions that can refer to types that may eagerly reference types
+ * that have not yet been defined.
+ */
+export interface MaybeForwardRefExpression<T extends o.Expression = o.Expression> {
+    /**
+     * The unwrapped expression.
+     */
+    expression: T;
+    /**
+     * Specified whether the `expression` contains a reference to something that has not yet been
+     * defined, and whether the expression is still wrapped in a `forwardRef()` call.
+     *
+     * If this value is `ForwardRefHandling.None` then the `expression` is safe to use as-is.
+     *
+     * Otherwise the `expression` was wrapped in a call to `forwardRef()` and 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 full AOT compilation it can be safe to unwrap the `forwardRef()` call up front if the
+     * expression will actually be evaluated lazily inside a function call after the value of
+     * `expression` has been defined.
+     *
+     * But in other cases, such as partial AOT compilation or JIT compilation the expression will be
+     * evaluated eagerly in top level code so will need to continue to be wrapped in a `forwardRef()`
+     * call.
+     *
+     */
+    forwardRef: ForwardRefHandling;
+}
+export declare function createMayBeForwardRefExpression<T extends o.Expression>(expression: T, forwardRef: ForwardRefHandling): MaybeForwardRefExpression<T>;
+/**
+ * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
+ * `forwardRef()` call.
+ *
+ * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
+ * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
+ * in the code.
+ *
+ * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
+ * `packages/compiler/src/jit_compiler_facade.ts` for more information.
+ */
+export declare function convertFromMaybeForwardRefExpression({ expression, forwardRef, }: MaybeForwardRefExpression): o.Expression;
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+export declare function generateForwardRef(expr: o.Expression): o.Expression;
+/**
+ * Specifies how a forward ref has been handled in a MaybeForwardRefExpression
+ */
+export declare const enum ForwardRefHandling {
+    /** The expression was not wrapped in a `forwardRef()` call in the first place. */
+    None = 0,
+    /** The expression is still wrapped in a `forwardRef()` call. */
+    Wrapped = 1,
+    /** The expression was wrapped in a `forwardRef()` call but has since been unwrapped. */
+    Unwrapped = 2
+}

package/transform/compiler/src/render3/util.js

@@ -1,7 +1,18 @@
 "use strict";
+/**
+ * @license
+ * Copyright Google LLC 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
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,15 +30,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeWithParameters = void 0;
-/**
- * @license
- * Copyright Google LLC 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
- */
+exports.generateForwardRef = exports.convertFromMaybeForwardRefExpression = exports.createMayBeForwardRefExpression = exports.typeWithParameters = void 0;
 const o = __importStar(require("../output/output_ast"));
+const r3_identifiers_1 = require("./r3_identifiers");
 function typeWithParameters(type, numParams) {
     if (numParams === 0) {
         return o.expressionType(type);
@@ -39,3 +44,41 @@ function typeWithParameters(type, numParams) {
     return o.expressionType(type, undefined, params);
 }
 exports.typeWithParameters = typeWithParameters;
+function createMayBeForwardRefExpression(expression, forwardRef) {
+    return { expression, forwardRef };
+}
+exports.createMayBeForwardRefExpression = createMayBeForwardRefExpression;
+/**
+ * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
+ * `forwardRef()` call.
+ *
+ * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
+ * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
+ * in the code.
+ *
+ * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
+ * `packages/compiler/src/jit_compiler_facade.ts` for more information.
+ */
+function convertFromMaybeForwardRefExpression({ expression, forwardRef, }) {
+    switch (forwardRef) {
+        case 0 /* ForwardRefHandling.None */:
+        case 1 /* ForwardRefHandling.Wrapped */:
+            return expression;
+        case 2 /* ForwardRefHandling.Unwrapped */:
+            return generateForwardRef(expression);
+    }
+}
+exports.convertFromMaybeForwardRefExpression = convertFromMaybeForwardRefExpression;
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+function generateForwardRef(expr) {
+    return o
+        .importExpr(r3_identifiers_1.Identifiers.forwardRef)
+        .callFn([o.fn([], [new o.ReturnStatement(expr)])]);
+}
+exports.generateForwardRef = generateForwardRef;

package/transform/compiler/src/render3/view/util.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/transform/compiler-cli/src/ngtsc/annotations/{src → common/src}/util.d.ts

@@ -5,11 +5,11 @@
  * 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 { Expression, R3DependencyMetadata, R3Reference } from '../../../../../compiler';
-import { R3FactoryMetadata } from '../../../../../compiler';
-import { FactoryTarget } from '../../../../../compiler/src/render3/partial/api';
+import { Expression, R3DependencyMetadata, R3Reference } from '../../../../../../compiler';
+import { R3FactoryMetadata } from '../../../../../../compiler';
+import { FactoryTarget } from '../../../../../../compiler/src/render3/partial/api';
 import * as ts from 'typescript';
-import { ClassDeclaration, CtorParameter, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference, UnavailableValue } from '../../reflection';
+import { ClassDeclaration, CtorParameter, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference, UnavailableValue } from '../../../reflection';
 export declare type ConstructorDeps = {
     deps: R3DependencyMetadata[];
 } | {
@@ -89,3 +89,4 @@ export declare function wrapFunctionExpressionsInParens(expression: ts.Expressio
  */
 export declare function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference;
 export declare function toFactoryMetadata(meta: Omit<R3FactoryMetadata, 'target'>, target: FactoryTarget): R3FactoryMetadata;
+export declare function isAbstractClassDeclaration(clazz: ClassDeclaration): boolean;