@angular/compiler-cli 11.2.9 → 11.2.13

package/src/ngtsc/typecheck/src/tcb_util.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/src/tcb_util" />
 import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
-import { ClassDeclaration } from '@angular/compiler-cli/src/ngtsc/reflection';
+import { ClassDeclaration, ReflectionHost } from '@angular/compiler-cli/src/ngtsc/reflection';
 import * as ts from 'typescript';
 import { Reference } from '../../imports';
 import { FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping } from '../api';
@@ -29,7 +29,28 @@ export interface TemplateSourceResolver {
      */
     toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }
-export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>): boolean;
+/**
+ * Indicates whether a particular component requires an inline type check block.
+ *
+ * This is not a boolean state as inlining might only be required to get the best possible
+ * type-checking, but the component could theoretically still be checked without it.
+ */
+export declare enum TcbInliningRequirement {
+    /**
+     * There is no way to type check this component without inlining.
+     */
+    MustInline = 0,
+    /**
+     * Inlining should be used due to the component's generic bounds, but a non-inlining fallback
+     * method can be used if that's not possible.
+     */
+    ShouldInlineForGenericBounds = 1,
+    /**
+     * There is no requirement for this component's TCB to be inlined.
+     */
+    None = 2
+}
+export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, reflector: ReflectionHost): TcbInliningRequirement;
 /** Maps a shim position back to a template location. */
 export declare function getTemplateMapping(shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver, isDiagnosticRequest: boolean): FullTemplateMapping | null;
 export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node | null;
@@ -40,3 +61,4 @@ export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId,
  * returns null.
  */
 export declare function findSourceLocation(node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticsRequest: boolean): SourceLocation | null;
+export declare function checkIfGenericTypeBoundsAreContextFree(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost): boolean;

package/src/ngtsc/typecheck/src/tcb_util.js

@@ -11,37 +11,61 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/typecheck/src/tcb_util", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/src/ngtsc/typecheck/src/comments", "@angular/compiler-cli/src/ngtsc/typecheck/src/ts_util"], factory);
+        define("@angular/compiler-cli/src/ngtsc/typecheck/src/tcb_util", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/src/ngtsc/typecheck/src/comments", "@angular/compiler-cli/src/ngtsc/typecheck/src/ts_util", "@angular/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.findSourceLocation = exports.findTypeCheckBlock = exports.getTemplateMapping = exports.requiresInlineTypeCheckBlock = void 0;
+    exports.checkIfGenericTypeBoundsAreContextFree = exports.findSourceLocation = exports.findTypeCheckBlock = exports.getTemplateMapping = exports.requiresInlineTypeCheckBlock = exports.TcbInliningRequirement = void 0;
     var tslib_1 = require("tslib");
     var ts = require("typescript");
     var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
     var comments_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/comments");
     var ts_util_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/ts_util");
-    function requiresInlineTypeCheckBlock(node, usedPipes) {
+    var type_parameter_emitter_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter");
+    /**
+     * Indicates whether a particular component requires an inline type check block.
+     *
+     * This is not a boolean state as inlining might only be required to get the best possible
+     * type-checking, but the component could theoretically still be checked without it.
+     */
+    var TcbInliningRequirement;
+    (function (TcbInliningRequirement) {
+        /**
+         * There is no way to type check this component without inlining.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["MustInline"] = 0] = "MustInline";
+        /**
+         * Inlining should be used due to the component's generic bounds, but a non-inlining fallback
+         * method can be used if that's not possible.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["ShouldInlineForGenericBounds"] = 1] = "ShouldInlineForGenericBounds";
+        /**
+         * There is no requirement for this component's TCB to be inlined.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["None"] = 2] = "None";
+    })(TcbInliningRequirement = exports.TcbInliningRequirement || (exports.TcbInliningRequirement = {}));
+    function requiresInlineTypeCheckBlock(node, usedPipes, reflector) {
         // In order to qualify for a declared TCB (not inline) two conditions must be met:
         // 1) the class must be exported
-        // 2) it must not have constrained generic types
+        // 2) it must not have contextual generic type bounds
         if (!ts_util_1.checkIfClassIsExported(node)) {
             // Condition 1 is false, the class is not exported.
-            return true;
+            return TcbInliningRequirement.MustInline;
         }
-        else if (!ts_util_1.checkIfGenericTypesAreUnbound(node)) {
-            // Condition 2 is false, the class has constrained generic types
-            return true;
+        else if (!checkIfGenericTypeBoundsAreContextFree(node, reflector)) {
+            // Condition 2 is false, the class has constrained generic types. It should be checked with an
+            // inline TCB if possible, but can potentially use fallbacks to avoid inlining if not.
+            return TcbInliningRequirement.ShouldInlineForGenericBounds;
         }
         else if (Array.from(usedPipes.values())
             .some(function (pipeRef) { return !ts_util_1.checkIfClassIsExported(pipeRef.node); })) {
             // If one of the pipes used by the component is not exported, a non-inline TCB will not be able
             // to import it, so this requires an inline TCB.
-            return true;
+            return TcbInliningRequirement.MustInline;
         }
         else {
-            return false;
+            return TcbInliningRequirement.None;
         }
     }
     exports.requiresInlineTypeCheckBlock = requiresInlineTypeCheckBlock;
@@ -132,5 +156,10 @@
             return commentText;
         }) || null;
     }
+    function checkIfGenericTypeBoundsAreContextFree(node, reflector) {
+        // Generic type parameters are considered context free if they can be emitted into any context.
+        return new type_parameter_emitter_1.TypeParameterEmitter(node.typeParameters, reflector).canEmit();
+    }
+    exports.checkIfGenericTypeBoundsAreContextFree = checkIfGenericTypeBoundsAreContextFree;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tcb_util.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AbsoluteSourceSpan, ParseSourceSpan} from '@angular/compiler';\nimport {ClassDeclaration} from '@angular/compiler-cli/src/ngtsc/reflection';\nimport * as ts from 'typescript';\n\nimport {Reference} from '../../imports';\nimport {getTokenAtPosition} from '../../util/src/typescript';\nimport {FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping} from '../api';\n\nimport {hasIgnoreForDiagnosticsMarker, readSpanComment} from './comments';\nimport {checkIfClassIsExported, checkIfGenericTypesAreUnbound} from './ts_util';\n\n/**\n * Adapter interface which allows the template type-checking diagnostics code to interpret offsets\n * in a TCB and map them back to original locations in the template.\n */\nexport interface TemplateSourceResolver {\n  getTemplateId(node: ts.ClassDeclaration): TemplateId;\n\n  /**\n   * For the given template id, retrieve the original source mapping which describes how the offsets\n   * in the template should be interpreted.\n   */\n  getSourceMapping(id: TemplateId): TemplateSourceMapping;\n\n  /**\n   * Convert an absolute source span associated with the given template id into a full\n   * `ParseSourceSpan`. The returned parse span has line and column numbers in addition to only\n   * absolute offsets and gives access to the original template source.\n   */\n  toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan|null;\n}\n\nexport function requiresInlineTypeCheckBlock(\n    node: ClassDeclaration<ts.ClassDeclaration>,\n    usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>): boolean {\n  // In order to qualify for a declared TCB (not inline) two conditions must be met:\n  // 1) the class must be exported\n  // 2) it must not have constrained generic types\n  if (!checkIfClassIsExported(node)) {\n    // Condition 1 is false, the class is not exported.\n    return true;\n  } else if (!checkIfGenericTypesAreUnbound(node)) {\n    // Condition 2 is false, the class has constrained generic types\n    return true;\n  } else if (Array.from(usedPipes.values())\n                 .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {\n    // If one of the pipes used by the component is not exported, a non-inline TCB will not be able\n    // to import it, so this requires an inline TCB.\n    return true;\n  } else {\n    return false;\n  }\n}\n\n/** Maps a shim position back to a template location. */\nexport function getTemplateMapping(\n    shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver,\n    isDiagnosticRequest: boolean): FullTemplateMapping|null {\n  const node = getTokenAtPosition(shimSf, position);\n  const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);\n  if (sourceLocation === null) {\n    return null;\n  }\n\n  const mapping = resolver.getSourceMapping(sourceLocation.id);\n  const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);\n  if (span === null) {\n    return null;\n  }\n  // TODO(atscott): Consider adding a context span by walking up from `node` until we get a\n  // different span.\n  return {sourceLocation, templateSourceMapping: mapping, span};\n}\n\nexport function findTypeCheckBlock(\n    file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node|null {\n  for (const stmt of file.statements) {\n    if (ts.isFunctionDeclaration(stmt) && getTemplateId(stmt, file, isDiagnosticRequest) === id) {\n      return stmt;\n    }\n  }\n  return null;\n}\n\n/**\n * Traverses up the AST starting from the given node to extract the source location from comments\n * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore\n * marker comment is found up the tree (and this is part of a diagnostic request), this function\n * returns null.\n */\nexport function findSourceLocation(\n    node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticsRequest: boolean): SourceLocation|null {\n  // Search for comments until the TCB's function declaration is encountered.\n  while (node !== undefined && !ts.isFunctionDeclaration(node)) {\n    if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {\n      // There's an ignore marker on this node, so the diagnostic should not be reported.\n      return null;\n    }\n\n    const span = readSpanComment(node, sourceFile);\n    if (span !== null) {\n      // Once the positional information has been extracted, search further up the TCB to extract\n      // the unique id that is attached with the TCB's function declaration.\n      const id = getTemplateId(node, sourceFile, isDiagnosticsRequest);\n      if (id === null) {\n        return null;\n      }\n      return {id, span};\n    }\n\n    node = node.parent;\n  }\n\n  return null;\n}\n\nfunction getTemplateId(\n    node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticRequest: boolean): TemplateId|null {\n  // Walk up to the function declaration of the TCB, the file information is attached there.\n  while (!ts.isFunctionDeclaration(node)) {\n    if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {\n      // There's an ignore marker on this node, so the diagnostic should not be reported.\n      return null;\n    }\n    node = node.parent;\n\n    // Bail once we have reached the root.\n    if (node === undefined) {\n      return null;\n    }\n  }\n\n  const start = node.getFullStart();\n  return ts.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {\n    if (kind !== ts.SyntaxKind.MultiLineCommentTrivia) {\n      return null;\n    }\n    const commentText = sourceFile.text.substring(pos + 2, end - 2);\n    return commentText;\n  }) as TemplateId || null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tcb_util.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;IAIH,+BAAiC;IAGjC,kFAA6D;IAG7D,mFAA0E;IAC1E,iFAAgF;IAChF,+GAA8D;IAuB9D;;;;;OAKG;IACH,IAAY,sBAgBX;IAhBD,WAAY,sBAAsB;QAChC;;WAEG;QACH,+EAAU,CAAA;QAEV;;;WAGG;QACH,mHAA4B,CAAA;QAE5B;;WAEG;QACH,mEAAI,CAAA;IACN,CAAC,EAhBW,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAgBjC;IAED,SAAgB,4BAA4B,CACxC,IAA2C,EAC3C,SAAwE,EACxE,SAAyB;QAC3B,kFAAkF;QAClF,gCAAgC;QAChC,qDAAqD;QACrD,IAAI,CAAC,gCAAsB,CAAC,IAAI,CAAC,EAAE;YACjC,mDAAmD;YACnD,OAAO,sBAAsB,CAAC,UAAU,CAAC;SAC1C;aAAM,IAAI,CAAC,sCAAsC,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE;YACnE,8FAA8F;YAC9F,sFAAsF;YACtF,OAAO,sBAAsB,CAAC,4BAA4B,CAAC;SAC5D;aAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;aACzB,IAAI,CAAC,UAAA,OAAO,IAAI,OAAA,CAAC,gCAAsB,CAAC,OAAO,CAAC,IAAI,CAAC,EAArC,CAAqC,CAAC,EAAE;YACtE,+FAA+F;YAC/F,gDAAgD;YAChD,OAAO,sBAAsB,CAAC,UAAU,CAAC;SAC1C;aAAM;YACL,OAAO,sBAAsB,CAAC,IAAI,CAAC;SACpC;IACH,CAAC;IAtBD,oEAsBC;IAED,wDAAwD;IACxD,SAAgB,kBAAkB,CAC9B,MAAqB,EAAE,QAAgB,EAAE,QAAgC,EACzE,mBAA4B;QAC9B,IAAM,IAAI,GAAG,+BAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAClD,IAAM,cAAc,GAAG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC;QAC7E,IAAI,cAAc,KAAK,IAAI,EAAE;YAC3B,OAAO,IAAI,CAAC;SACb;QAED,IAAM,OAAO,GAAG,QAAQ,CAAC,gBAAgB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC7D,IAAM,IAAI,GAAG,QAAQ,CAAC,iBAAiB,CAAC,cAAc,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;QAChF,IAAI,IAAI,KAAK,IAAI,EAAE;YACjB,OAAO,IAAI,CAAC;SACb;QACD,yFAAyF;QACzF,kBAAkB;QAClB,OAAO,EAAC,cAAc,gBAAA,EAAE,qBAAqB,EAAE,OAAO,EAAE,IAAI,MAAA,EAAC,CAAC;IAChE,CAAC;IAjBD,gDAiBC;IAED,SAAgB,kBAAkB,CAC9B,IAAmB,EAAE,EAAc,EAAE,mBAA4B;;;YACnE,KAAmB,IAAA,KAAA,iBAAA,IAAI,CAAC,UAAU,CAAA,gBAAA,4BAAE;gBAA/B,IAAM,IAAI,WAAA;gBACb,IAAI,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,mBAAmB,CAAC,KAAK,EAAE,EAAE;oBAC3F,OAAO,IAAI,CAAC;iBACb;aACF;;;;;;;;;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IARD,gDAQC;IAED;;;;;OAKG;IACH,SAAgB,kBAAkB,CAC9B,IAAa,EAAE,UAAyB,EAAE,oBAA6B;QACzE,2EAA2E;QAC3E,OAAO,IAAI,KAAK,SAAS,IAAI,CAAC,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE;YAC5D,IAAI,wCAA6B,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,oBAAoB,EAAE;gBAC3E,mFAAmF;gBACnF,OAAO,IAAI,CAAC;aACb;YAED,IAAM,IAAI,GAAG,0BAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC/C,IAAI,IAAI,KAAK,IAAI,EAAE;gBACjB,2FAA2F;gBAC3F,sEAAsE;gBACtE,IAAM,EAAE,GAAG,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,oBAAoB,CAAC,CAAC;gBACjE,IAAI,EAAE,KAAK,IAAI,EAAE;oBACf,OAAO,IAAI,CAAC;iBACb;gBACD,OAAO,EAAC,EAAE,IAAA,EAAE,IAAI,MAAA,EAAC,CAAC;aACnB;YAED,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;SACpB;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAxBD,gDAwBC;IAED,SAAS,aAAa,CAClB,IAAa,EAAE,UAAyB,EAAE,mBAA4B;QACxE,0FAA0F;QAC1F,OAAO,CAAC,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE;YACtC,IAAI,wCAA6B,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB,EAAE;gBAC1E,mFAAmF;gBACnF,OAAO,IAAI,CAAC;aACb;YACD,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;YAEnB,sCAAsC;YACtC,IAAI,IAAI,KAAK,SAAS,EAAE;gBACtB,OAAO,IAAI,CAAC;aACb;SACF;QAED,IAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,OAAO,EAAE,CAAC,0BAA0B,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,UAAC,GAAG,EAAE,GAAG,EAAE,IAAI;YAC1E,IAAI,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,EAAE;gBACjD,OAAO,IAAI,CAAC;aACb;YACD,IAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YAChE,OAAO,WAAW,CAAC;QACrB,CAAC,CAAe,IAAI,IAAI,CAAC;IAC3B,CAAC;IAED,SAAgB,sCAAsC,CAClD,IAA2C,EAAE,SAAyB;QACxE,+FAA+F;QAC/F,OAAO,IAAI,6CAAoB,CAAC,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IAC5E,CAAC;IAJD,wFAIC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AbsoluteSourceSpan, ParseSourceSpan} from '@angular/compiler';\nimport {ClassDeclaration, ReflectionHost} from '@angular/compiler-cli/src/ngtsc/reflection';\nimport * as ts from 'typescript';\n\nimport {Reference} from '../../imports';\nimport {getTokenAtPosition} from '../../util/src/typescript';\nimport {FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping} from '../api';\n\nimport {hasIgnoreForDiagnosticsMarker, readSpanComment} from './comments';\nimport {checkIfClassIsExported, checkIfGenericTypesAreUnbound} from './ts_util';\nimport {TypeParameterEmitter} from './type_parameter_emitter';\n\n/**\n * Adapter interface which allows the template type-checking diagnostics code to interpret offsets\n * in a TCB and map them back to original locations in the template.\n */\nexport interface TemplateSourceResolver {\n  getTemplateId(node: ts.ClassDeclaration): TemplateId;\n\n  /**\n   * For the given template id, retrieve the original source mapping which describes how the offsets\n   * in the template should be interpreted.\n   */\n  getSourceMapping(id: TemplateId): TemplateSourceMapping;\n\n  /**\n   * Convert an absolute source span associated with the given template id into a full\n   * `ParseSourceSpan`. The returned parse span has line and column numbers in addition to only\n   * absolute offsets and gives access to the original template source.\n   */\n  toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan|null;\n}\n\n/**\n * Indicates whether a particular component requires an inline type check block.\n *\n * This is not a boolean state as inlining might only be required to get the best possible\n * type-checking, but the component could theoretically still be checked without it.\n */\nexport enum TcbInliningRequirement {\n  /**\n   * There is no way to type check this component without inlining.\n   */\n  MustInline,\n\n  /**\n   * Inlining should be used due to the component's generic bounds, but a non-inlining fallback\n   * method can be used if that's not possible.\n   */\n  ShouldInlineForGenericBounds,\n\n  /**\n   * There is no requirement for this component's TCB to be inlined.\n   */\n  None,\n}\n\nexport function requiresInlineTypeCheckBlock(\n    node: ClassDeclaration<ts.ClassDeclaration>,\n    usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>,\n    reflector: ReflectionHost): TcbInliningRequirement {\n  // In order to qualify for a declared TCB (not inline) two conditions must be met:\n  // 1) the class must be exported\n  // 2) it must not have contextual generic type bounds\n  if (!checkIfClassIsExported(node)) {\n    // Condition 1 is false, the class is not exported.\n    return TcbInliningRequirement.MustInline;\n  } else if (!checkIfGenericTypeBoundsAreContextFree(node, reflector)) {\n    // Condition 2 is false, the class has constrained generic types. It should be checked with an\n    // inline TCB if possible, but can potentially use fallbacks to avoid inlining if not.\n    return TcbInliningRequirement.ShouldInlineForGenericBounds;\n  } else if (Array.from(usedPipes.values())\n                 .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {\n    // If one of the pipes used by the component is not exported, a non-inline TCB will not be able\n    // to import it, so this requires an inline TCB.\n    return TcbInliningRequirement.MustInline;\n  } else {\n    return TcbInliningRequirement.None;\n  }\n}\n\n/** Maps a shim position back to a template location. */\nexport function getTemplateMapping(\n    shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver,\n    isDiagnosticRequest: boolean): FullTemplateMapping|null {\n  const node = getTokenAtPosition(shimSf, position);\n  const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);\n  if (sourceLocation === null) {\n    return null;\n  }\n\n  const mapping = resolver.getSourceMapping(sourceLocation.id);\n  const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);\n  if (span === null) {\n    return null;\n  }\n  // TODO(atscott): Consider adding a context span by walking up from `node` until we get a\n  // different span.\n  return {sourceLocation, templateSourceMapping: mapping, span};\n}\n\nexport function findTypeCheckBlock(\n    file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node|null {\n  for (const stmt of file.statements) {\n    if (ts.isFunctionDeclaration(stmt) && getTemplateId(stmt, file, isDiagnosticRequest) === id) {\n      return stmt;\n    }\n  }\n  return null;\n}\n\n/**\n * Traverses up the AST starting from the given node to extract the source location from comments\n * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore\n * marker comment is found up the tree (and this is part of a diagnostic request), this function\n * returns null.\n */\nexport function findSourceLocation(\n    node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticsRequest: boolean): SourceLocation|null {\n  // Search for comments until the TCB's function declaration is encountered.\n  while (node !== undefined && !ts.isFunctionDeclaration(node)) {\n    if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {\n      // There's an ignore marker on this node, so the diagnostic should not be reported.\n      return null;\n    }\n\n    const span = readSpanComment(node, sourceFile);\n    if (span !== null) {\n      // Once the positional information has been extracted, search further up the TCB to extract\n      // the unique id that is attached with the TCB's function declaration.\n      const id = getTemplateId(node, sourceFile, isDiagnosticsRequest);\n      if (id === null) {\n        return null;\n      }\n      return {id, span};\n    }\n\n    node = node.parent;\n  }\n\n  return null;\n}\n\nfunction getTemplateId(\n    node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticRequest: boolean): TemplateId|null {\n  // Walk up to the function declaration of the TCB, the file information is attached there.\n  while (!ts.isFunctionDeclaration(node)) {\n    if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {\n      // There's an ignore marker on this node, so the diagnostic should not be reported.\n      return null;\n    }\n    node = node.parent;\n\n    // Bail once we have reached the root.\n    if (node === undefined) {\n      return null;\n    }\n  }\n\n  const start = node.getFullStart();\n  return ts.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {\n    if (kind !== ts.SyntaxKind.MultiLineCommentTrivia) {\n      return null;\n    }\n    const commentText = sourceFile.text.substring(pos + 2, end - 2);\n    return commentText;\n  }) as TemplateId || null;\n}\n\nexport function checkIfGenericTypeBoundsAreContextFree(\n    node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost): boolean {\n  // Generic type parameters are considered context free if they can be emitted into any context.\n  return new TypeParameterEmitter(node.typeParameters, reflector).canEmit();\n}\n"]}

package/src/ngtsc/typecheck/src/type_check_block.d.ts

@@ -14,6 +14,31 @@ import { TemplateId, TypeCheckableDirectiveMeta, TypeCheckBlockMetadata } from '
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
+/**
+ * Controls how generics for the component context class will be handled during TCB generation.
+ */
+export declare enum TcbGenericContextBehavior {
+    /**
+     * References to generic parameter bounds will be emitted via the `TypeParameterEmitter`.
+     *
+     * The caller must verify that all parameter bounds are emittable in order to use this mode.
+     */
+    UseEmitter = 0,
+    /**
+     * Generic parameter declarations will be copied directly from the `ts.ClassDeclaration` of the
+     * component class.
+     *
+     * The caller must only use the generated TCB code in a context where such copies will still be
+     * valid, such as an inline type check block.
+     */
+    CopyClassNodes = 1,
+    /**
+     * Any generic parameters for the component context class will be set to `any`.
+     *
+     * Produces a less useful type, but is always safe to use.
+     */
+    FallbackToAny = 2
+}
 /**
  * Given a `ts.ClassDeclaration` for a component, and metadata regarding that component, compose a
  * "type check block" function.
@@ -35,8 +60,10 @@ import { OutOfBandDiagnosticRecorder } from './oob';
  * and bindings.
  * @param oobRecorder used to record errors regarding template elements which could not be correctly
  * translated into types during TCB generation.
+ * @param genericContextBehavior controls how generic parameters (especially parameters with generic
+ * bounds) will be referenced from the generated TCB code.
  */
-export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder): ts.FunctionDeclaration;
+export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): ts.FunctionDeclaration;
 /**
  * A code generation operation that's involved in the construction of a Type Check Block.
  *