@angular/compiler-cli 10.1.3 → 10.2.0

package/src/ngtsc/typecheck/api/api.js

@@ -32,4 +32,4 @@
         UpdateMode[UpdateMode["Incremental"] = 1] = "Incremental";
     })(UpdateMode = exports.UpdateMode || (exports.UpdateMode = {}));
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/api/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAqUH,IAAY,UAaX;IAbD,WAAY,UAAU;QACpB;;;;WAIG;QACH,mDAAQ,CAAA;QAER;;;WAGG;QACH,yDAAW,CAAA;IACb,CAAC,EAbW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAarB","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 {BoundTarget, DirectiveMeta, SchemaMetadata} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath} from '../../file_system';\nimport {Reference} from '../../imports';\nimport {ClassPropertyMapping, DirectiveTypeCheckMeta} from '../../metadata';\nimport {ClassDeclaration} from '../../reflection';\n\n\n/**\n * Extension of `DirectiveMeta` that includes additional information required to type-check the\n * usage of a particular directive.\n */\nexport interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {\n  ref: Reference<ClassDeclaration>;\n  queries: string[];\n  inputs: ClassPropertyMapping;\n  outputs: ClassPropertyMapping;\n}\n\nexport type TemplateId = string&{__brand: 'TemplateId'};\n\n/**\n * Metadata required in addition to a component class in order to generate a type check block (TCB)\n * for that component.\n */\nexport interface TypeCheckBlockMetadata {\n  /**\n   * A unique identifier for the class which gave rise to this TCB.\n   *\n   * This can be used to map errors back to the `ts.ClassDeclaration` for the component.\n   */\n  id: TemplateId;\n\n  /**\n   * Semantic information about the template of the component.\n   */\n  boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;\n\n  /*\n   * Pipes used in the template of the component.\n   */\n  pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;\n\n  /**\n   * Schemas that apply to this template.\n   */\n  schemas: SchemaMetadata[];\n}\n\nexport interface TypeCtorMetadata {\n  /**\n   * The name of the requested type constructor function.\n   */\n  fnName: string;\n\n  /**\n   * Whether to generate a body for the function or not.\n   */\n  body: boolean;\n\n  /**\n   * Input, output, and query field names in the type which should be included as constructor input.\n   */\n  fields: {inputs: string[]; outputs: string[]; queries: string[];};\n\n  /**\n   * `Set` of field names which have type coercion enabled.\n   */\n  coercedInputFields: Set<string>;\n}\n\nexport interface TypeCheckingConfig {\n  /**\n   * Whether to check the left-hand side type of binding operations.\n   *\n   * For example, if this is `false` then the expression `[input]=\"expr\"` will have `expr` type-\n   * checked, but not the assignment of the resulting type to the `input` property of whichever\n   * directive or component is receiving the binding. If set to `true`, both sides of the assignment\n   * are checked.\n   *\n   * This flag only affects bindings to components/directives. Bindings to the DOM are checked if\n   * `checkTypeOfDomBindings` is set.\n   */\n  checkTypeOfInputBindings: boolean;\n\n  /**\n   * Whether to honor the access modifiers on input bindings for the component/directive.\n   *\n   * If a template binding attempts to assign to an input that is private/protected/readonly,\n   * this will produce errors when enabled but will not when disabled.\n   */\n  honorAccessModifiersForInputBindings: boolean;\n\n  /**\n   * Whether to use strict null types for input bindings for directives.\n   *\n   * If this is `true`, applications that are compiled with TypeScript's `strictNullChecks` enabled\n   * will produce type errors for bindings which can evaluate to `undefined` or `null` where the\n   * inputs's type does not include `undefined` or `null` in its type. If set to `false`, all\n   * binding expressions are wrapped in a non-null assertion operator to effectively disable strict\n   * null checks. This may be particularly useful when the directive is from a library that is not\n   * compiled with `strictNullChecks` enabled.\n   *\n   * If `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  strictNullInputBindings: boolean;\n\n  /**\n   * Whether to check text attributes that happen to be consumed by a directive or component.\n   *\n   * For example, in a template containing `<input matInput disabled>` the `disabled` attribute ends\n   * up being consumed as an input with type `boolean` by the `matInput` directive. At runtime, the\n   * input will be set to the attribute's string value, which is an empty string for attributes\n   * without a value, so with this flag set to `true`, an error would be reported. If set to\n   * `false`, text attributes will never report an error.\n   *\n   * Note that if `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  checkTypeOfAttributes: boolean;\n\n  /**\n   * Whether to check the left-hand side type of binding operations to DOM properties.\n   *\n   * As `checkTypeOfBindings`, but only applies to bindings to DOM properties.\n   *\n   * This does not affect the use of the `DomSchemaChecker` to validate the template against the DOM\n   * schema. Rather, this flag is an experimental, not yet complete feature which uses the\n   * lib.dom.d.ts DOM typings in TypeScript to validate that DOM bindings are of the correct type\n   * for assignability to the underlying DOM element properties.\n   */\n  checkTypeOfDomBindings: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for directive outputs or\n   * animation events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on the generic type of\n   * `EventEmitter`/`Subject` of the output. If set to `false`, the `$event` variable will be of\n   * type `any`.\n   */\n  checkTypeOfOutputEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for animations.\n   *\n   * If this is `true`, the type of `$event` will be `AnimationEvent` from `@angular/animations`.\n   * If set to `false`, the `$event` variable will be of type `any`.\n   */\n  checkTypeOfAnimationEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings to DOM events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on TypeScript's\n   * `HTMLElementEventMap`, with a fallback to the native `Event` type. If set to `false`, the\n   * `$event` variable will be of type `any`.\n   */\n  checkTypeOfDomEvents: boolean;\n\n  /**\n   * Whether to infer the type of local references to DOM elements.\n   *\n   * If this is `true`, the type of a `#ref` variable on a DOM node in the template will be\n   * determined by the type of `document.createElement` for the given DOM node type. If set to\n   * `false`, the type of `ref` for DOM nodes will be `any`.\n   */\n  checkTypeOfDomReferences: boolean;\n\n\n  /**\n   * Whether to infer the type of local references.\n   *\n   * If this is `true`, the type of a `#ref` variable that points to a directive or `TemplateRef` in\n   * the template will be inferred correctly. If set to `false`, the type of `ref` for will be\n   * `any`.\n   */\n  checkTypeOfNonDomReferences: boolean;\n\n  /**\n   * Whether to include type information from pipes in the type-checking operation.\n   *\n   * If this is `true`, then the pipe's type signature for `transform()` will be used to check the\n   * usage of the pipe. If this is `false`, then the result of applying a pipe will be `any`, and\n   * the types of the pipe's value and arguments will not be matched against the `transform()`\n   * method.\n   */\n  checkTypeOfPipes: boolean;\n\n  /**\n   * Whether to narrow the types of template contexts.\n   */\n  applyTemplateContextGuards: boolean;\n\n  /**\n   * Whether to use a strict type for null-safe navigation operations.\n   *\n   * If this is `false`, then the return type of `a?.b` or `a?()` will be `any`. If set to `true`,\n   * then the return type of `a?.b` for example will be the same as the type of the ternary\n   * expression `a != null ? a.b : a`.\n   */\n  strictSafeNavigationTypes: boolean;\n\n  /**\n   * Whether to descend into template bodies and check any bindings there.\n   */\n  checkTemplateBodies: boolean;\n\n  /**\n   * Whether to check resolvable queries.\n   *\n   * This is currently an unsupported feature.\n   */\n  checkQueries: false;\n\n  /**\n   * Whether to use any generic types of the context component.\n   *\n   * If this is `true`, then if the context component has generic types, those will be mirrored in\n   * the template type-checking context. If `false`, any generic type parameters of the context\n   * component will be set to `any` during type-checking.\n   */\n  useContextGenericType: boolean;\n\n  /**\n   * Whether or not to infer types for object and array literals in the template.\n   *\n   * If this is `true`, then the type of an object or an array literal in the template will be the\n   * same type that TypeScript would infer if the literal appeared in code. If `false`, then such\n   * literals are cast to `any` when declared.\n   */\n  strictLiteralTypes: boolean;\n}\n\n\nexport type TemplateSourceMapping =\n    DirectTemplateSourceMapping|IndirectTemplateSourceMapping|ExternalTemplateSourceMapping;\n\n/**\n * A mapping to an inline template in a TS file.\n *\n * `ParseSourceSpan`s for this template should be accurate for direct reporting in a TS error\n * message.\n */\nexport interface DirectTemplateSourceMapping {\n  type: 'direct';\n  node: ts.StringLiteral|ts.NoSubstitutionTemplateLiteral;\n}\n\n/**\n * A mapping to a template which is still in a TS file, but where the node positions in any\n * `ParseSourceSpan`s are not accurate for one reason or another.\n *\n * This can occur if the template expression was interpolated in a way where the compiler could not\n * construct a contiguous mapping for the template string. The `node` refers to the `template`\n * expression.\n */\nexport interface IndirectTemplateSourceMapping {\n  type: 'indirect';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n}\n\n/**\n * A mapping to a template declared in an external HTML file, where node positions in\n * `ParseSourceSpan`s represent accurate offsets into the external file.\n *\n * In this case, the given `node` refers to the `templateUrl` expression.\n */\nexport interface ExternalTemplateSourceMapping {\n  type: 'external';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n  templateUrl: string;\n}\n\n/**\n * Abstracts the operation of determining which shim file will host a particular component's\n * template type-checking code.\n *\n * Different consumers of the type checking infrastructure may choose different approaches to\n * optimize for their specific use case (for example, the command-line compiler optimizes for\n * efficient `ts.Program` reuse in watch mode).\n */\nexport interface ComponentToShimMappingStrategy {\n  /**\n   * Given a component, determine a path to the shim file into which that component's type checking\n   * code will be generated.\n   *\n   * A major constraint is that components in different input files must not share the same shim\n   * file. The behavior of the template type-checking system is undefined if this is violated.\n   */\n  shimPathForComponent(node: ts.ClassDeclaration): AbsoluteFsPath;\n}\n\n/**\n * Strategy used to manage a `ts.Program` which contains template type-checking code and update it\n * over time.\n *\n * This abstraction allows both the Angular compiler itself as well as the language service to\n * implement efficient template type-checking using common infrastructure.\n */\nexport interface TypeCheckingProgramStrategy extends ComponentToShimMappingStrategy {\n  /**\n   * Whether this strategy supports modifying user files (inline modifications) in addition to\n   * modifying type-checking shims.\n   */\n  readonly supportsInlineOperations: boolean;\n\n  /**\n   * Retrieve the latest version of the program, containing all the updates made thus far.\n   */\n  getProgram(): ts.Program;\n\n  /**\n   * Incorporate a set of changes to either augment or completely replace the type-checking code\n   * included in the type-checking program.\n   */\n  updateFiles(contents: Map<AbsoluteFsPath, string>, updateMode: UpdateMode): void;\n}\n\nexport enum UpdateMode {\n  /**\n   * A complete update creates a completely new overlay of type-checking code on top of the user's\n   * original program, which doesn't include type-checking code from previous calls to\n   * `updateFiles`.\n   */\n  Complete,\n\n  /**\n   * An incremental update changes the contents of some files in the type-checking program without\n   * reverting any prior changes.\n   */\n  Incremental,\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/api/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IA2UH,IAAY,UAaX;IAbD,WAAY,UAAU;QACpB;;;;WAIG;QACH,mDAAQ,CAAA;QAER;;;WAGG;QACH,yDAAW,CAAA;IACb,CAAC,EAbW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAarB","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 {BoundTarget, DirectiveMeta, SchemaMetadata} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath} from '../../file_system';\nimport {Reference} from '../../imports';\nimport {ClassPropertyMapping, DirectiveTypeCheckMeta} from '../../metadata';\nimport {ClassDeclaration} from '../../reflection';\n\n\n/**\n * Extension of `DirectiveMeta` that includes additional information required to type-check the\n * usage of a particular directive.\n */\nexport interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {\n  ref: Reference<ClassDeclaration>;\n  queries: string[];\n  inputs: ClassPropertyMapping;\n  outputs: ClassPropertyMapping;\n}\n\nexport type TemplateId = string&{__brand: 'TemplateId'};\n\n/**\n * Metadata required in addition to a component class in order to generate a type check block (TCB)\n * for that component.\n */\nexport interface TypeCheckBlockMetadata {\n  /**\n   * A unique identifier for the class which gave rise to this TCB.\n   *\n   * This can be used to map errors back to the `ts.ClassDeclaration` for the component.\n   */\n  id: TemplateId;\n\n  /**\n   * Semantic information about the template of the component.\n   */\n  boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;\n\n  /*\n   * Pipes used in the template of the component.\n   */\n  pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;\n\n  /**\n   * Schemas that apply to this template.\n   */\n  schemas: SchemaMetadata[];\n}\n\nexport interface TypeCtorMetadata {\n  /**\n   * The name of the requested type constructor function.\n   */\n  fnName: string;\n\n  /**\n   * Whether to generate a body for the function or not.\n   */\n  body: boolean;\n\n  /**\n   * Input, output, and query field names in the type which should be included as constructor input.\n   */\n  fields: {inputs: string[]; outputs: string[]; queries: string[];};\n\n  /**\n   * `Set` of field names which have type coercion enabled.\n   */\n  coercedInputFields: Set<string>;\n}\n\nexport interface TypeCheckingConfig {\n  /**\n   * Whether to check the left-hand side type of binding operations.\n   *\n   * For example, if this is `false` then the expression `[input]=\"expr\"` will have `expr` type-\n   * checked, but not the assignment of the resulting type to the `input` property of whichever\n   * directive or component is receiving the binding. If set to `true`, both sides of the assignment\n   * are checked.\n   *\n   * This flag only affects bindings to components/directives. Bindings to the DOM are checked if\n   * `checkTypeOfDomBindings` is set.\n   */\n  checkTypeOfInputBindings: boolean;\n\n  /**\n   * Whether to honor the access modifiers on input bindings for the component/directive.\n   *\n   * If a template binding attempts to assign to an input that is private/protected/readonly,\n   * this will produce errors when enabled but will not when disabled.\n   */\n  honorAccessModifiersForInputBindings: boolean;\n\n  /**\n   * Whether to use strict null types for input bindings for directives.\n   *\n   * If this is `true`, applications that are compiled with TypeScript's `strictNullChecks` enabled\n   * will produce type errors for bindings which can evaluate to `undefined` or `null` where the\n   * inputs's type does not include `undefined` or `null` in its type. If set to `false`, all\n   * binding expressions are wrapped in a non-null assertion operator to effectively disable strict\n   * null checks. This may be particularly useful when the directive is from a library that is not\n   * compiled with `strictNullChecks` enabled.\n   *\n   * If `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  strictNullInputBindings: boolean;\n\n  /**\n   * Whether to check text attributes that happen to be consumed by a directive or component.\n   *\n   * For example, in a template containing `<input matInput disabled>` the `disabled` attribute ends\n   * up being consumed as an input with type `boolean` by the `matInput` directive. At runtime, the\n   * input will be set to the attribute's string value, which is an empty string for attributes\n   * without a value, so with this flag set to `true`, an error would be reported. If set to\n   * `false`, text attributes will never report an error.\n   *\n   * Note that if `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  checkTypeOfAttributes: boolean;\n\n  /**\n   * Whether to check the left-hand side type of binding operations to DOM properties.\n   *\n   * As `checkTypeOfBindings`, but only applies to bindings to DOM properties.\n   *\n   * This does not affect the use of the `DomSchemaChecker` to validate the template against the DOM\n   * schema. Rather, this flag is an experimental, not yet complete feature which uses the\n   * lib.dom.d.ts DOM typings in TypeScript to validate that DOM bindings are of the correct type\n   * for assignability to the underlying DOM element properties.\n   */\n  checkTypeOfDomBindings: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for directive outputs or\n   * animation events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on the generic type of\n   * `EventEmitter`/`Subject` of the output. If set to `false`, the `$event` variable will be of\n   * type `any`.\n   */\n  checkTypeOfOutputEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for animations.\n   *\n   * If this is `true`, the type of `$event` will be `AnimationEvent` from `@angular/animations`.\n   * If set to `false`, the `$event` variable will be of type `any`.\n   */\n  checkTypeOfAnimationEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings to DOM events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on TypeScript's\n   * `HTMLElementEventMap`, with a fallback to the native `Event` type. If set to `false`, the\n   * `$event` variable will be of type `any`.\n   */\n  checkTypeOfDomEvents: boolean;\n\n  /**\n   * Whether to infer the type of local references to DOM elements.\n   *\n   * If this is `true`, the type of a `#ref` variable on a DOM node in the template will be\n   * determined by the type of `document.createElement` for the given DOM node type. If set to\n   * `false`, the type of `ref` for DOM nodes will be `any`.\n   */\n  checkTypeOfDomReferences: boolean;\n\n\n  /**\n   * Whether to infer the type of local references.\n   *\n   * If this is `true`, the type of a `#ref` variable that points to a directive or `TemplateRef` in\n   * the template will be inferred correctly. If set to `false`, the type of `ref` for will be\n   * `any`.\n   */\n  checkTypeOfNonDomReferences: boolean;\n\n  /**\n   * Whether to include type information from pipes in the type-checking operation.\n   *\n   * If this is `true`, then the pipe's type signature for `transform()` will be used to check the\n   * usage of the pipe. If this is `false`, then the result of applying a pipe will be `any`, and\n   * the types of the pipe's value and arguments will not be matched against the `transform()`\n   * method.\n   */\n  checkTypeOfPipes: boolean;\n\n  /**\n   * Whether to narrow the types of template contexts.\n   */\n  applyTemplateContextGuards: boolean;\n\n  /**\n   * Whether to use a strict type for null-safe navigation operations.\n   *\n   * If this is `false`, then the return type of `a?.b` or `a?()` will be `any`. If set to `true`,\n   * then the return type of `a?.b` for example will be the same as the type of the ternary\n   * expression `a != null ? a.b : a`.\n   */\n  strictSafeNavigationTypes: boolean;\n\n  /**\n   * Whether to descend into template bodies and check any bindings there.\n   */\n  checkTemplateBodies: boolean;\n\n  /**\n   * Whether to always apply DOM schema checks in template bodies, independently of the\n   * `checkTemplateBodies` setting.\n   */\n  alwaysCheckSchemaInTemplateBodies: boolean;\n\n  /**\n   * Whether to check resolvable queries.\n   *\n   * This is currently an unsupported feature.\n   */\n  checkQueries: false;\n\n  /**\n   * Whether to use any generic types of the context component.\n   *\n   * If this is `true`, then if the context component has generic types, those will be mirrored in\n   * the template type-checking context. If `false`, any generic type parameters of the context\n   * component will be set to `any` during type-checking.\n   */\n  useContextGenericType: boolean;\n\n  /**\n   * Whether or not to infer types for object and array literals in the template.\n   *\n   * If this is `true`, then the type of an object or an array literal in the template will be the\n   * same type that TypeScript would infer if the literal appeared in code. If `false`, then such\n   * literals are cast to `any` when declared.\n   */\n  strictLiteralTypes: boolean;\n}\n\n\nexport type TemplateSourceMapping =\n    DirectTemplateSourceMapping|IndirectTemplateSourceMapping|ExternalTemplateSourceMapping;\n\n/**\n * A mapping to an inline template in a TS file.\n *\n * `ParseSourceSpan`s for this template should be accurate for direct reporting in a TS error\n * message.\n */\nexport interface DirectTemplateSourceMapping {\n  type: 'direct';\n  node: ts.StringLiteral|ts.NoSubstitutionTemplateLiteral;\n}\n\n/**\n * A mapping to a template which is still in a TS file, but where the node positions in any\n * `ParseSourceSpan`s are not accurate for one reason or another.\n *\n * This can occur if the template expression was interpolated in a way where the compiler could not\n * construct a contiguous mapping for the template string. The `node` refers to the `template`\n * expression.\n */\nexport interface IndirectTemplateSourceMapping {\n  type: 'indirect';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n}\n\n/**\n * A mapping to a template declared in an external HTML file, where node positions in\n * `ParseSourceSpan`s represent accurate offsets into the external file.\n *\n * In this case, the given `node` refers to the `templateUrl` expression.\n */\nexport interface ExternalTemplateSourceMapping {\n  type: 'external';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n  templateUrl: string;\n}\n\n/**\n * Abstracts the operation of determining which shim file will host a particular component's\n * template type-checking code.\n *\n * Different consumers of the type checking infrastructure may choose different approaches to\n * optimize for their specific use case (for example, the command-line compiler optimizes for\n * efficient `ts.Program` reuse in watch mode).\n */\nexport interface ComponentToShimMappingStrategy {\n  /**\n   * Given a component, determine a path to the shim file into which that component's type checking\n   * code will be generated.\n   *\n   * A major constraint is that components in different input files must not share the same shim\n   * file. The behavior of the template type-checking system is undefined if this is violated.\n   */\n  shimPathForComponent(node: ts.ClassDeclaration): AbsoluteFsPath;\n}\n\n/**\n * Strategy used to manage a `ts.Program` which contains template type-checking code and update it\n * over time.\n *\n * This abstraction allows both the Angular compiler itself as well as the language service to\n * implement efficient template type-checking using common infrastructure.\n */\nexport interface TypeCheckingProgramStrategy extends ComponentToShimMappingStrategy {\n  /**\n   * Whether this strategy supports modifying user files (inline modifications) in addition to\n   * modifying type-checking shims.\n   */\n  readonly supportsInlineOperations: boolean;\n\n  /**\n   * Retrieve the latest version of the program, containing all the updates made thus far.\n   */\n  getProgram(): ts.Program;\n\n  /**\n   * Incorporate a set of changes to either augment or completely replace the type-checking code\n   * included in the type-checking program.\n   */\n  updateFiles(contents: Map<AbsoluteFsPath, string>, updateMode: UpdateMode): void;\n}\n\nexport enum UpdateMode {\n  /**\n   * A complete update creates a completely new overlay of type-checking code on top of the user's\n   * original program, which doesn't include type-checking code from previous calls to\n   * `updateFiles`.\n   */\n  Complete,\n\n  /**\n   * An incremental update changes the contents of some files in the type-checking program without\n   * reverting any prior changes.\n   */\n  Incremental,\n}\n"]}

package/src/ngtsc/typecheck/diagnostics/src/id.d.ts

@@ -6,6 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id" />
-import * as ts from 'typescript';
+import { DeclarationNode } from '../../../reflection';
 import { TemplateId } from '../../api';
-export declare function getTemplateId(clazz: ts.Declaration): TemplateId;
+export declare function getTemplateId(clazz: DeclarationNode): TemplateId;

package/src/ngtsc/typecheck/diagnostics/src/id.js

@@ -34,4 +34,4 @@
         return ("tcb" + sf[NEXT_TEMPLATE_ID]++);
     }
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3R5cGVjaGVjay9kaWFnbm9zdGljcy9zcmMvaWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7O0lBT0gsSUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzNDLElBQU0sZ0JBQWdCLEdBQUcsTUFBTSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFVcEQsU0FBZ0IsYUFBYSxDQUFDLEtBQXFCO1FBQ2pELElBQU0sSUFBSSxHQUFHLEtBQWdELENBQUM7UUFDOUQsSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssU0FBUyxFQUFFO1lBQ25DLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsQ0FBQztTQUM5RDtRQUNELE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBRSxDQUFDO0lBQzVCLENBQUM7SUFORCxzQ0FNQztJQUVELFNBQVMsa0JBQWtCLENBQUMsRUFBNEM7UUFDdEUsSUFBSSxFQUFFLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxTQUFTLEVBQUU7WUFDdEMsRUFBRSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxDQUFDO1NBQzFCO1FBQ0QsT0FBTyxDQUFDLFFBQU0sRUFBRSxDQUFDLGdCQUFnQixDQUFFLEVBQUksQ0FBZSxDQUFDO0lBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5cbmltcG9ydCB7VGVtcGxhdGVJZH0gZnJvbSAnLi4vLi4vYXBpJztcblxuXG5jb25zdCBURU1QTEFURV9JRCA9IFN5bWJvbCgnbmdUZW1wbGF0ZUlkJyk7XG5jb25zdCBORVhUX1RFTVBMQVRFX0lEID0gU3ltYm9sKCduZ05leHRUZW1wbGF0ZUlkJyk7XG5cbmludGVyZmFjZSBIYXNUZW1wbGF0ZUlkIHtcbiAgW1RFTVBMQVRFX0lEXTogVGVtcGxhdGVJZDtcbn1cblxuaW50ZXJmYWNlIEhhc05leHRUZW1wbGF0ZUlkIHtcbiAgW05FWFRfVEVNUExBVEVfSURdOiBudW1iZXI7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRUZW1wbGF0ZUlkKGNsYXp6OiB0cy5EZWNsYXJhdGlvbik6IFRlbXBsYXRlSWQge1xuICBjb25zdCBub2RlID0gY2xhenogYXMgdHMuRGVjbGFyYXRpb24gJiBQYXJ0aWFsPEhhc1RlbXBsYXRlSWQ+O1xuICBpZiAobm9kZVtURU1QTEFURV9JRF0gPT09IHVuZGVmaW5lZCkge1xuICAgIG5vZGVbVEVNUExBVEVfSURdID0gYWxsb2NhdGVUZW1wbGF0ZUlkKG5vZGUuZ2V0U291cmNlRmlsZSgpKTtcbiAgfVxuICByZXR1cm4gbm9kZVtURU1QTEFURV9JRF0hO1xufVxuXG5mdW5jdGlvbiBhbGxvY2F0ZVRlbXBsYXRlSWQoc2Y6IHRzLlNvdXJjZUZpbGUmUGFydGlhbDxIYXNOZXh0VGVtcGxhdGVJZD4pOiBUZW1wbGF0ZUlkIHtcbiAgaWYgKHNmW05FWFRfVEVNUExBVEVfSURdID09PSB1bmRlZmluZWQpIHtcbiAgICBzZltORVhUX1RFTVBMQVRFX0lEXSA9IDE7XG4gIH1cbiAgcmV0dXJuIChgdGNiJHtzZltORVhUX1RFTVBMQVRFX0lEXSErK31gKSBhcyBUZW1wbGF0ZUlkO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,13 +7,51 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/src/host" />
 import * as ts from 'typescript';
+/**
+ * Represents the `ts.CompilerHost` interface, with a transformation applied that turns all
+ * methods (even optional ones) into required fields (which may be `undefined`, if the method was
+ * optional).
+ */
+export declare type RequiredCompilerHostDelegations = {
+    [M in keyof Required<ts.CompilerHost>]: ts.CompilerHost[M];
+};
+/**
+ * Delegates all methods of `ts.CompilerHost` to a delegate, with the exception of
+ * `getSourceFile`, `fileExists` and `writeFile` which are implemented in `TypeCheckProgramHost`.
+ *
+ * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be
+ * generated for this class.
+ */
+export declare class DelegatingCompilerHost implements Omit<RequiredCompilerHostDelegations, 'getSourceFile' | 'fileExists' | 'writeFile'> {
+    protected delegate: ts.CompilerHost;
+    constructor(delegate: ts.CompilerHost);
+    private delegateMethod;
+    createHash: ((data: string) => string) | undefined;
+    directoryExists: ((directoryName: string) => boolean) | undefined;
+    getCancellationToken: (() => ts.CancellationToken) | undefined;
+    getCanonicalFileName: (fileName: string) => string;
+    getCurrentDirectory: () => string;
+    getDefaultLibFileName: (options: ts.CompilerOptions) => string;
+    getDefaultLibLocation: (() => string) | undefined;
+    getDirectories: ((path: string) => string[]) | undefined;
+    getEnvironmentVariable: ((name: string) => string | undefined) | undefined;
+    getNewLine: () => string;
+    getParsedCommandLine: ((fileName: string) => ts.ParsedCommandLine | undefined) | undefined;
+    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
+    readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
+    readFile: (fileName: string) => string | undefined;
+    realpath: ((path: string) => string) | undefined;
+    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedModule | undefined)[]) | undefined;
+    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
+    trace: ((s: string) => void) | undefined;
+    useCaseSensitiveFileNames: () => boolean;
+}
 /**
  * A `ts.CompilerHost` which augments source files with type checking code from a
  * `TypeCheckContext`.
  */
-export declare class TypeCheckProgramHost implements ts.CompilerHost {
+export declare class TypeCheckProgramHost extends DelegatingCompilerHost {
     private originalProgram;
-    private delegate;
     private shimExtensionPrefixes;
     /**
      * Map of source file names to `ts.SourceFile` instances.
@@ -30,17 +68,9 @@ export declare class TypeCheckProgramHost implements ts.CompilerHost {
      * `TypeCheckProgramHost` has its own `ShimReferenceTagger` to perform this function.
      */
     private shimTagger;
-    readonly resolveModuleNames?: ts.CompilerHost['resolveModuleNames'];
     constructor(sfMap: Map<string, ts.SourceFile>, originalProgram: ts.Program, delegate: ts.CompilerHost, shimExtensionPrefixes: string[]);
     getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined): ts.SourceFile | undefined;
     postProgramCreationCleanup(): void;
-    getDefaultLibFileName(options: ts.CompilerOptions): string;
-    writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError: ((message: string) => void) | undefined, sourceFiles: ReadonlyArray<ts.SourceFile> | undefined): void;
-    getCurrentDirectory(): string;
-    getDirectories?: (path: string) => string[];
-    getCanonicalFileName(fileName: string): string;
-    useCaseSensitiveFileNames(): boolean;
-    getNewLine(): string;
+    writeFile(): never;
     fileExists(fileName: string): boolean;
-    readFile(fileName: string): string | undefined;
 }

package/src/ngtsc/typecheck/src/host.js

@@ -11,22 +11,63 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/typecheck/src/host", ["require", "exports", "@angular/compiler-cli/src/ngtsc/shims"], factory);
+        define("@angular/compiler-cli/src/ngtsc/typecheck/src/host", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/shims"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.TypeCheckProgramHost = void 0;
+    exports.TypeCheckProgramHost = exports.DelegatingCompilerHost = void 0;
+    var tslib_1 = require("tslib");
     var shims_1 = require("@angular/compiler-cli/src/ngtsc/shims");
+    /**
+     * Delegates all methods of `ts.CompilerHost` to a delegate, with the exception of
+     * `getSourceFile`, `fileExists` and `writeFile` which are implemented in `TypeCheckProgramHost`.
+     *
+     * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be
+     * generated for this class.
+     */
+    var DelegatingCompilerHost = /** @class */ (function () {
+        function DelegatingCompilerHost(delegate) {
+            this.delegate = delegate;
+            // Excluded are 'getSourceFile', 'fileExists' and 'writeFile', which are actually implemented by
+            // `TypeCheckProgramHost` below.
+            this.createHash = this.delegateMethod('createHash');
+            this.directoryExists = this.delegateMethod('directoryExists');
+            this.getCancellationToken = this.delegateMethod('getCancellationToken');
+            this.getCanonicalFileName = this.delegateMethod('getCanonicalFileName');
+            this.getCurrentDirectory = this.delegateMethod('getCurrentDirectory');
+            this.getDefaultLibFileName = this.delegateMethod('getDefaultLibFileName');
+            this.getDefaultLibLocation = this.delegateMethod('getDefaultLibLocation');
+            this.getDirectories = this.delegateMethod('getDirectories');
+            this.getEnvironmentVariable = this.delegateMethod('getEnvironmentVariable');
+            this.getNewLine = this.delegateMethod('getNewLine');
+            this.getParsedCommandLine = this.delegateMethod('getParsedCommandLine');
+            this.getSourceFileByPath = this.delegateMethod('getSourceFileByPath');
+            this.readDirectory = this.delegateMethod('readDirectory');
+            this.readFile = this.delegateMethod('readFile');
+            this.realpath = this.delegateMethod('realpath');
+            this.resolveModuleNames = this.delegateMethod('resolveModuleNames');
+            this.resolveTypeReferenceDirectives = this.delegateMethod('resolveTypeReferenceDirectives');
+            this.trace = this.delegateMethod('trace');
+            this.useCaseSensitiveFileNames = this.delegateMethod('useCaseSensitiveFileNames');
+        }
+        DelegatingCompilerHost.prototype.delegateMethod = function (name) {
+            return this.delegate[name] !== undefined ? this.delegate[name].bind(this.delegate) :
+                undefined;
+        };
+        return DelegatingCompilerHost;
+    }());
+    exports.DelegatingCompilerHost = DelegatingCompilerHost;
     /**
      * A `ts.CompilerHost` which augments source files with type checking code from a
      * `TypeCheckContext`.
      */
-    var TypeCheckProgramHost = /** @class */ (function () {
+    var TypeCheckProgramHost = /** @class */ (function (_super) {
+        tslib_1.__extends(TypeCheckProgramHost, _super);
         function TypeCheckProgramHost(sfMap, originalProgram, delegate, shimExtensionPrefixes) {
-            this.originalProgram = originalProgram;
-            this.delegate = delegate;
-            this.shimExtensionPrefixes = shimExtensionPrefixes;
+            var _this = _super.call(this, delegate) || this;
+            _this.originalProgram = originalProgram;
+            _this.shimExtensionPrefixes = shimExtensionPrefixes;
             /**
              * The `ShimReferenceTagger` responsible for tagging `ts.SourceFile`s loaded via this host.
              *
@@ -37,14 +78,9 @@
              * order for those shims to be loaded, and then cleaned up afterwards. Thus the
              * `TypeCheckProgramHost` has its own `ShimReferenceTagger` to perform this function.
              */
-            this.shimTagger = new shims_1.ShimReferenceTagger(this.shimExtensionPrefixes);
-            this.sfMap = sfMap;
-            if (delegate.getDirectories !== undefined) {
-                this.getDirectories = function (path) { return delegate.getDirectories(path); };
-            }
-            if (delegate.resolveModuleNames !== undefined) {
-                this.resolveModuleNames = delegate.resolveModuleNames;
-            }
+            _this.shimTagger = new shims_1.ShimReferenceTagger(_this.shimExtensionPrefixes);
+            _this.sfMap = sfMap;
+            return _this;
         }
         TypeCheckProgramHost.prototype.getSourceFile = function (fileName, languageVersion, onError, shouldCreateNewSourceFile) {
             // Try to use the same `ts.SourceFile` as the original program, if possible. This guarantees
@@ -79,33 +115,14 @@
         TypeCheckProgramHost.prototype.postProgramCreationCleanup = function () {
             this.shimTagger.finalize();
         };
-        // The rest of the methods simply delegate to the underlying `ts.CompilerHost`.
-        TypeCheckProgramHost.prototype.getDefaultLibFileName = function (options) {
-            return this.delegate.getDefaultLibFileName(options);
-        };
-        TypeCheckProgramHost.prototype.writeFile = function (fileName, data, writeByteOrderMark, onError, sourceFiles) {
+        TypeCheckProgramHost.prototype.writeFile = function () {
             throw new Error("TypeCheckProgramHost should never write files");
         };
-        TypeCheckProgramHost.prototype.getCurrentDirectory = function () {
-            return this.delegate.getCurrentDirectory();
-        };
-        TypeCheckProgramHost.prototype.getCanonicalFileName = function (fileName) {
-            return this.delegate.getCanonicalFileName(fileName);
-        };
-        TypeCheckProgramHost.prototype.useCaseSensitiveFileNames = function () {
-            return this.delegate.useCaseSensitiveFileNames();
-        };
-        TypeCheckProgramHost.prototype.getNewLine = function () {
-            return this.delegate.getNewLine();
-        };
         TypeCheckProgramHost.prototype.fileExists = function (fileName) {
             return this.sfMap.has(fileName) || this.delegate.fileExists(fileName);
         };
-        TypeCheckProgramHost.prototype.readFile = function (fileName) {
-            return this.delegate.readFile(fileName);
-        };
         return TypeCheckProgramHost;
-    }());
+    }(DelegatingCompilerHost));
     exports.TypeCheckProgramHost = TypeCheckProgramHost;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/host.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 * as ts from 'typescript';\n\nimport {copyFileShimData, ShimReferenceTagger} from '../../shims';\n\n/**\n * A `ts.CompilerHost` which augments source files with type checking code from a\n * `TypeCheckContext`.\n */\nexport class TypeCheckProgramHost implements ts.CompilerHost {\n  /**\n   * Map of source file names to `ts.SourceFile` instances.\n   */\n  private sfMap: Map<string, ts.SourceFile>;\n\n  /**\n   * The `ShimReferenceTagger` responsible for tagging `ts.SourceFile`s loaded via this host.\n   *\n   * The `TypeCheckProgramHost` is used in the creation of a new `ts.Program`. Even though this new\n   * program is based on a prior one, TypeScript will still start from the root files and enumerate\n   * all source files to include in the new program.  This means that just like during the original\n   * program's creation, these source files must be tagged with references to per-file shims in\n   * order for those shims to be loaded, and then cleaned up afterwards. Thus the\n   * `TypeCheckProgramHost` has its own `ShimReferenceTagger` to perform this function.\n   */\n  private shimTagger = new ShimReferenceTagger(this.shimExtensionPrefixes);\n\n  readonly resolveModuleNames?: ts.CompilerHost['resolveModuleNames'];\n\n  constructor(\n      sfMap: Map<string, ts.SourceFile>, private originalProgram: ts.Program,\n      private delegate: ts.CompilerHost, private shimExtensionPrefixes: string[]) {\n    this.sfMap = sfMap;\n\n    if (delegate.getDirectories !== undefined) {\n      this.getDirectories = (path: string) => delegate.getDirectories!(path);\n    }\n\n    if (delegate.resolveModuleNames !== undefined) {\n      this.resolveModuleNames = delegate.resolveModuleNames;\n    }\n  }\n\n  getSourceFile(\n      fileName: string, languageVersion: ts.ScriptTarget,\n      onError?: ((message: string) => void)|undefined,\n      shouldCreateNewSourceFile?: boolean|undefined): ts.SourceFile|undefined {\n    // Try to use the same `ts.SourceFile` as the original program, if possible. This guarantees\n    // that program reuse will be as efficient as possible.\n    let delegateSf: ts.SourceFile|undefined = this.originalProgram.getSourceFile(fileName);\n    if (delegateSf === undefined) {\n      // Something went wrong and a source file is being requested that's not in the original\n      // program. Just in case, try to retrieve it from the delegate.\n      delegateSf = this.delegate.getSourceFile(\n          fileName, languageVersion, onError, shouldCreateNewSourceFile)!;\n    }\n    if (delegateSf === undefined) {\n      return undefined;\n    }\n\n    // Look for replacements.\n    let sf: ts.SourceFile;\n    if (this.sfMap.has(fileName)) {\n      sf = this.sfMap.get(fileName)!;\n      copyFileShimData(delegateSf, sf);\n    } else {\n      sf = delegateSf;\n    }\n    // TypeScript doesn't allow returning redirect source files. To avoid unforseen errors we\n    // return the original source file instead of the redirect target.\n    const redirectInfo = (sf as any).redirectInfo;\n    if (redirectInfo !== undefined) {\n      sf = redirectInfo.unredirected;\n    }\n\n    this.shimTagger.tag(sf);\n    return sf;\n  }\n\n  postProgramCreationCleanup(): void {\n    this.shimTagger.finalize();\n  }\n\n  // The rest of the methods simply delegate to the underlying `ts.CompilerHost`.\n\n  getDefaultLibFileName(options: ts.CompilerOptions): string {\n    return this.delegate.getDefaultLibFileName(options);\n  }\n\n  writeFile(\n      fileName: string, data: string, writeByteOrderMark: boolean,\n      onError: ((message: string) => void)|undefined,\n      sourceFiles: ReadonlyArray<ts.SourceFile>|undefined): void {\n    throw new Error(`TypeCheckProgramHost should never write files`);\n  }\n\n  getCurrentDirectory(): string {\n    return this.delegate.getCurrentDirectory();\n  }\n\n  getDirectories?: (path: string) => string[];\n\n  getCanonicalFileName(fileName: string): string {\n    return this.delegate.getCanonicalFileName(fileName);\n  }\n\n  useCaseSensitiveFileNames(): boolean {\n    return this.delegate.useCaseSensitiveFileNames();\n  }\n\n  getNewLine(): string {\n    return this.delegate.getNewLine();\n  }\n\n  fileExists(fileName: string): boolean {\n    return this.sfMap.has(fileName) || this.delegate.fileExists(fileName);\n  }\n\n  readFile(fileName: string): string|undefined {\n    return this.delegate.readFile(fileName);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/host.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 * as ts from 'typescript';\n\nimport {copyFileShimData, ShimReferenceTagger} from '../../shims';\n\n/**\n * Represents the `ts.CompilerHost` interface, with a transformation applied that turns all\n * methods (even optional ones) into required fields (which may be `undefined`, if the method was\n * optional).\n */\nexport type RequiredCompilerHostDelegations = {\n  [M in keyof Required<ts.CompilerHost>]: ts.CompilerHost[M];\n};\n\n/**\n * Delegates all methods of `ts.CompilerHost` to a delegate, with the exception of\n * `getSourceFile`, `fileExists` and `writeFile` which are implemented in `TypeCheckProgramHost`.\n *\n * If a new method is added to `ts.CompilerHost` which is not delegated, a type error will be\n * generated for this class.\n */\nexport class DelegatingCompilerHost implements\n    Omit<RequiredCompilerHostDelegations, 'getSourceFile'|'fileExists'|'writeFile'> {\n  constructor(protected delegate: ts.CompilerHost) {}\n\n  private delegateMethod<M extends keyof ts.CompilerHost>(name: M): ts.CompilerHost[M] {\n    return this.delegate[name] !== undefined ? (this.delegate[name] as any).bind(this.delegate) :\n                                               undefined;\n  }\n\n  // Excluded are 'getSourceFile', 'fileExists' and 'writeFile', which are actually implemented by\n  // `TypeCheckProgramHost` below.\n  createHash = this.delegateMethod('createHash');\n  directoryExists = this.delegateMethod('directoryExists');\n  getCancellationToken = this.delegateMethod('getCancellationToken');\n  getCanonicalFileName = this.delegateMethod('getCanonicalFileName');\n  getCurrentDirectory = this.delegateMethod('getCurrentDirectory');\n  getDefaultLibFileName = this.delegateMethod('getDefaultLibFileName');\n  getDefaultLibLocation = this.delegateMethod('getDefaultLibLocation');\n  getDirectories = this.delegateMethod('getDirectories');\n  getEnvironmentVariable = this.delegateMethod('getEnvironmentVariable');\n  getNewLine = this.delegateMethod('getNewLine');\n  getParsedCommandLine = this.delegateMethod('getParsedCommandLine');\n  getSourceFileByPath = this.delegateMethod('getSourceFileByPath');\n  readDirectory = this.delegateMethod('readDirectory');\n  readFile = this.delegateMethod('readFile');\n  realpath = this.delegateMethod('realpath');\n  resolveModuleNames = this.delegateMethod('resolveModuleNames');\n  resolveTypeReferenceDirectives = this.delegateMethod('resolveTypeReferenceDirectives');\n  trace = this.delegateMethod('trace');\n  useCaseSensitiveFileNames = this.delegateMethod('useCaseSensitiveFileNames');\n}\n\n/**\n * A `ts.CompilerHost` which augments source files with type checking code from a\n * `TypeCheckContext`.\n */\nexport class TypeCheckProgramHost extends DelegatingCompilerHost {\n  /**\n   * Map of source file names to `ts.SourceFile` instances.\n   */\n  private sfMap: Map<string, ts.SourceFile>;\n\n  /**\n   * The `ShimReferenceTagger` responsible for tagging `ts.SourceFile`s loaded via this host.\n   *\n   * The `TypeCheckProgramHost` is used in the creation of a new `ts.Program`. Even though this new\n   * program is based on a prior one, TypeScript will still start from the root files and enumerate\n   * all source files to include in the new program.  This means that just like during the original\n   * program's creation, these source files must be tagged with references to per-file shims in\n   * order for those shims to be loaded, and then cleaned up afterwards. Thus the\n   * `TypeCheckProgramHost` has its own `ShimReferenceTagger` to perform this function.\n   */\n  private shimTagger = new ShimReferenceTagger(this.shimExtensionPrefixes);\n\n  constructor(\n      sfMap: Map<string, ts.SourceFile>, private originalProgram: ts.Program,\n      delegate: ts.CompilerHost, private shimExtensionPrefixes: string[]) {\n    super(delegate);\n    this.sfMap = sfMap;\n  }\n\n  getSourceFile(\n      fileName: string, languageVersion: ts.ScriptTarget,\n      onError?: ((message: string) => void)|undefined,\n      shouldCreateNewSourceFile?: boolean|undefined): ts.SourceFile|undefined {\n    // Try to use the same `ts.SourceFile` as the original program, if possible. This guarantees\n    // that program reuse will be as efficient as possible.\n    let delegateSf: ts.SourceFile|undefined = this.originalProgram.getSourceFile(fileName);\n    if (delegateSf === undefined) {\n      // Something went wrong and a source file is being requested that's not in the original\n      // program. Just in case, try to retrieve it from the delegate.\n      delegateSf = this.delegate.getSourceFile(\n          fileName, languageVersion, onError, shouldCreateNewSourceFile)!;\n    }\n    if (delegateSf === undefined) {\n      return undefined;\n    }\n\n    // Look for replacements.\n    let sf: ts.SourceFile;\n    if (this.sfMap.has(fileName)) {\n      sf = this.sfMap.get(fileName)!;\n      copyFileShimData(delegateSf, sf);\n    } else {\n      sf = delegateSf;\n    }\n    // TypeScript doesn't allow returning redirect source files. To avoid unforseen errors we\n    // return the original source file instead of the redirect target.\n    const redirectInfo = (sf as any).redirectInfo;\n    if (redirectInfo !== undefined) {\n      sf = redirectInfo.unredirected;\n    }\n\n    this.shimTagger.tag(sf);\n    return sf;\n  }\n\n  postProgramCreationCleanup(): void {\n    this.shimTagger.finalize();\n  }\n\n  writeFile(): never {\n    throw new Error(`TypeCheckProgramHost should never write files`);\n  }\n\n  fileExists(fileName: string): boolean {\n    return this.sfMap.has(fileName) || this.delegate.fileExists(fileName);\n  }\n}\n"]}