@angular/compiler-cli 21.2.3 → 21.2.5

package/linker/src/file_linker/linker_environment.d.ts

@@ -12,14 +12,14 @@ import { AstFactory } from '../../../src/ngtsc/translator';
 import { AstHost } from '../ast/ast_host';
 import { LinkerOptions } from './linker_options';
 import { Translator } from './translator';
-export declare class LinkerEnvironment<TStatement, TExpression> {
+export declare class LinkerEnvironment<TStatement, TExpression, TType> {
     readonly fileSystem: ReadonlyFileSystem;
     readonly logger: Logger;
     readonly host: AstHost<TExpression>;
-    readonly factory: AstFactory<TStatement, TExpression>;
+    readonly factory: AstFactory<TStatement, TExpression, TType>;
     readonly options: LinkerOptions;
-    readonly translator: Translator<TStatement, TExpression>;
+    readonly translator: Translator<TStatement, TExpression, TType>;
     readonly sourceFileLoader: SourceFileLoader | null;
     private constructor();
-    static create<TStatement, TExpression>(fileSystem: ReadonlyFileSystem, logger: Logger, host: AstHost<TExpression>, factory: AstFactory<TStatement, TExpression>, options: Partial<LinkerOptions>): LinkerEnvironment<TStatement, TExpression>;
+    static create<TStatement, TExpression, TType>(fileSystem: ReadonlyFileSystem, logger: Logger, host: AstHost<TExpression>, factory: AstFactory<TStatement, TExpression, TType>, options: Partial<LinkerOptions>): LinkerEnvironment<TStatement, TExpression, TType>;
 }

package/linker/src/file_linker/partial_linkers/partial_linker_selector.d.ts

@@ -48,7 +48,7 @@ export interface LinkerRange<TExpression> {
  * `minVersion` of the partial-declaration should be updated, the new linker implementation should
  * be added to the end of the collection, and the version of the previous linker should be updated.
  */
-export declare function createLinkerMap<TStatement, TExpression>(environment: LinkerEnvironment<TStatement, TExpression>, sourceUrl: AbsoluteFsPath, code: string): Map<string, LinkerRange<TExpression>[]>;
+export declare function createLinkerMap<TStatement, TExpression, TType>(environment: LinkerEnvironment<TStatement, TExpression, TType>, sourceUrl: AbsoluteFsPath, code: string): Map<string, LinkerRange<TExpression>[]>;
 /**
  * A helper that selects the appropriate `PartialLinker` for a given declaration.
  *

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,7 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "21.2.3";
+export declare const PLACEHOLDER_VERSION = "21.2.5";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/linker/src/file_linker/translator.d.ts

@@ -13,9 +13,9 @@ import { AstFactory } from '../../../src/ngtsc/translator/src/api/ast_factory';
  * Generic translator helper class, which exposes methods for translating expressions and
  * statements.
  */
-export declare class Translator<TStatement, TExpression> {
+export declare class Translator<TStatement, TExpression, TType> {
     private factory;
-    constructor(factory: AstFactory<TStatement, TExpression>);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>);
     /**
      * Translate the given output AST in the context of an expression.
      */

package/linker/src/linker_import_generator.d.ts

@@ -14,10 +14,10 @@ import { AstFactory, ImportGenerator, ImportRequest } from '../../src/ngtsc/tran
  * must be achieved by property access on an `ng` namespace identifier, which is passed in via the
  * constructor.
  */
-export declare class LinkerImportGenerator<TStatement, TExpression> implements ImportGenerator<null, TExpression> {
+export declare class LinkerImportGenerator<TStatement, TExpression, TType> implements ImportGenerator<null, TExpression> {
     private factory;
     private ngImport;
-    constructor(factory: AstFactory<TStatement, TExpression>, ngImport: TExpression);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>, ngImport: TExpression);
     addImport(request: ImportRequest<null>): TExpression;
     private assertModuleName;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "21.2.3",
+  "version": "21.2.5",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -43,7 +43,7 @@
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "@angular/compiler": "21.2.3",
+    "@angular/compiler": "21.2.5",
     "typescript": ">=5.9 <6.1"
   },
   "peerDependenciesMeta": {

package/src/ngtsc/translator/src/api/ast_factory.d.ts

@@ -12,7 +12,7 @@
  * It is up to the caller to do this - e.g. only call `createTaggedTemplate()` or pass `let`|`const`
  * to `createVariableDeclaration()` if the final JS will allow it.
  */
-export interface AstFactory<TStatement, TExpression> {
+export interface AstFactory<TStatement, TExpression, TType> {
     /**
      * Attach the `leadingComments` to the given `statement` node.
      *
@@ -84,7 +84,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body a statement (or a block of statements) that are the body of the function.
      */
-    createFunctionDeclaration(functionName: string, parameters: string[], body: TStatement): TStatement;
+    createFunctionDeclaration(functionName: string, parameters: Parameter<TType>[], body: TStatement): TStatement;
     /**
      * Create an expression that represents a function
      * (e.g. `function foo(param1, param2) { stmt; }`).
@@ -93,7 +93,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body a statement (or a block of statements) that are the body of the function.
      */
-    createFunctionExpression(functionName: string | null, parameters: string[], body: TStatement): TExpression;
+    createFunctionExpression(functionName: string | null, parameters: Parameter<TType>[], body: TStatement): TExpression;
     /**
      * Create an expression that represents an arrow function
      * (e.g. `(param1, param2) => body`).
@@ -101,7 +101,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body an expression or block of statements that are the body of the function.
      */
-    createArrowFunctionExpression(parameters: string[], body: TExpression | TStatement): TExpression;
+    createArrowFunctionExpression(parameters: Parameter<TType>[], body: TExpression | TStatement): TExpression;
     /**
      * Creates an expression that represents a dynamic import
      * (e.g. `import('./some/path')`)
@@ -216,9 +216,9 @@ export interface AstFactory<TStatement, TExpression> {
      *
      * @param variableName the name of the variable.
      * @param initializer if not `null` then this expression is assigned to the declared variable.
-     * @param type whether this variable should be declared as `var`, `let` or `const`.
+     * @param variableType whether this variable should be declared as `var`, `let` or `const`.
      */
-    createVariableDeclaration(variableName: string, initializer: TExpression | null, type: VariableDeclarationType): TStatement;
+    createVariableDeclaration(variableName: string, initializer: TExpression | null, variableType: VariableDeclarationType, type: TType | null): TStatement;
     /**
      * Create a regular expression literal (e.g. `/\d+/g`).
      *
@@ -232,6 +232,32 @@ export interface AstFactory<TStatement, TExpression> {
      * @param target Expression of the spread element.
      */
     createSpreadElement(expression: TExpression): TExpression;
+    /**
+     * Create a type node for a built-in type.
+     * @param type Type that should be created.
+     */
+    createBuiltInType(type: BuiltInType): TType;
+    /**
+     * Create an expression type.
+     * @param expression Expression to be turned into a type node.
+     * @param typeParams Type parameters for the expression.
+     */
+    createExpressionType(expression: TExpression, typeParams: TType[] | null): TType;
+    /**
+     * Create an array type.
+     * @param elementType Type of the array elements.
+     */
+    createArrayType(elementType: TType): TType;
+    /**
+     * Create a map type.
+     * @param valueType Type of the map values.
+     */
+    createMapType(valueType: TType): TType;
+    /**
+     * Forward a transplanted type.
+     * @param type Type to be transplanted, if supported.
+     */
+    transplantType(type: TType): TType;
     /**
      * Attach a source map range to the given node.
      *
@@ -249,6 +275,12 @@ export type VariableDeclarationType = 'const' | 'let' | 'var';
  * The unary operators supported by the `AstFactory`.
  */
 export type UnaryOperator = '+' | '-' | '!';
+/** Supported built-in types. */
+export type BuiltInType = 'any' | 'boolean' | 'number' | 'string' | 'function' | 'never' | 'unknown';
+export interface Parameter<TType> {
+    name: string;
+    type: TType | null;
+}
 /**
  * The binary operators supported by the `AstFactory`.
  */

package/src/ngtsc/translator/src/translator.d.ts

@@ -16,14 +16,14 @@ export interface TranslatorOptions<TExpression> {
     recordWrappedNode?: RecordWrappedNodeFn<TExpression>;
     annotateForClosureCompiler?: boolean;
 }
-export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression> implements o.ExpressionVisitor, o.StatementVisitor {
+export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression, TType> implements o.ExpressionVisitor, o.StatementVisitor, o.TypeVisitor {
     private factory;
     private imports;
     private contextFile;
     private downlevelTaggedTemplates;
     private downlevelVariableDeclarations;
     private recordWrappedNode;
-    constructor(factory: AstFactory<TStatement, TExpression>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
     visitDeclareVarStmt(stmt: o.DeclareVarStmt, context: Context): TStatement;
     visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
     visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;
@@ -37,6 +37,11 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
     visitRegularExpressionLiteral(ast: o.RegularExpressionLiteralExpr, context: any): TExpression;
     visitLocalizedString(ast: o.LocalizedString, context: Context): TExpression;
+    visitBuiltinType(ast: o.BuiltinType): TType | null;
+    visitExpressionType(ast: o.ExpressionType, context: Context): TType;
+    visitArrayType(ast: o.ArrayType, context: Context): TType;
+    visitMapType(ast: o.MapType, context: Context): TType;
+    visitTransplantedType(type: o.TransplantedType<TType>): TType;
     private createTaggedTemplateExpression;
     /**
      * Translate the tagged template literal into a call that is compatible with ES5, using the
@@ -66,4 +71,5 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     private setSourceMapRange;
     private attachComments;
     private getTemplateLiteralFromAst;
+    private translateParams;
 }

package/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -6,11 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
+import { AstFactory, BinaryOperator, BuiltInType, LeadingComment, ObjectLiteralProperty, Parameter, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
 /**
  * A TypeScript flavoured implementation of the AstFactory.
  */
-export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression> {
+export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression, ts.TypeNode> {
     private annotateForClosureCompiler;
     private externalSourceFiles;
     private readonly UNARY_OPERATORS;
@@ -27,9 +27,10 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
     createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
     createDynamicImport(url: string | ts.Expression): ts.CallExpression;
-    createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;
-    createFunctionExpression(functionName: string | null, parameters: string[], body: ts.Statement): ts.Expression;
-    createArrowFunctionExpression(parameters: string[], body: ts.Statement | ts.Expression): ts.Expression;
+    createFunctionDeclaration(functionName: string, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Statement;
+    createFunctionExpression(functionName: string | null, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Expression;
+    createArrowFunctionExpression(parameters: Parameter<ts.TypeNode>[], body: ts.Statement | ts.Expression): ts.Expression;
+    private createParameter;
     createIdentifier: (text: string) => ts.Identifier;
     createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
     createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
@@ -45,9 +46,14 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
     createVoidExpression: (expression: ts.Expression) => ts.VoidExpression;
     createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
-    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, type: VariableDeclarationType): ts.Statement;
+    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, variableType: VariableDeclarationType, type: ts.TypeNode | null): ts.Statement;
     createRegularExpressionLiteral(body: string, flags: string | null): ts.Expression;
     setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
+    createBuiltInType(type: BuiltInType): ts.TypeNode;
+    createExpressionType(expression: ts.Expression, typeParams: ts.TypeNode[] | null): ts.TypeNode;
+    createArrayType(elementType: ts.TypeNode): ts.TypeNode;
+    createMapType(valueType: ts.TypeNode): ts.TypeNode;
+    transplantType(type: ts.TypeNode): ts.TypeNode;
 }
 export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
 export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;

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

@@ -64,7 +64,7 @@ export interface TcbDirectiveMetadata {
     typeParameters: TcbTypeParameter[] | null;
     inputs: ClassPropertyMapping<TcbInputMapping>;
     outputs: ClassPropertyMapping;
-    hasRequiresInlineTypeCtor: boolean;
+    requiresInlineTypeCtor: boolean;
     ngTemplateGuards: TemplateGuardMeta[];
     hasNgTemplateContextGuard: boolean;
     hasNgFieldDirective: boolean;
@@ -79,6 +79,7 @@ export interface TcbDirectiveMetadata {
 export interface TcbComponentMetadata {
     ref: TcbReferenceMetadata;
     typeParameters: TcbTypeParameter[] | null;
+    typeArguments: string[] | null;
 }
 export interface TcbTypeCheckBlockMetadata {
     id: TypeCheckId;

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

@@ -8,5 +8,4 @@
 export { FileTypeCheckingData, TemplateTypeCheckerImpl } from './src/checker';
 export { TypeCheckContextImpl, getTemplateDiagnostics } from './src/context';
 export { TypeCheckShimGenerator } from './src/shim';
-export { typeCheckFilePath } from './src/type_check_file';
 export { createHostElement } from './src/host_bindings';

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

@@ -5,39 +5,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TemplateDiagnostic } from '../api';
 import { TypeCheckSourceResolver } from './tcb_util';
-/**
- * Wraps the node in parenthesis such that inserted span comments become attached to the proper
- * node. This is an alias for `ts.factory.createParenthesizedExpression` with the benefit that it
- * signifies that the inserted parenthesis are for diagnostic purposes, not for correctness of the
- * rendered TCB code.
- *
- * Note that it is important that nodes and its attached comment are not wrapped into parenthesis
- * by default, as it prevents correct translation of e.g. diagnostics produced for incorrect method
- * arguments. Such diagnostics would then be produced for the parenthesised node whereas the
- * positional comment would be located within that node, resulting in a mismatch.
- */
-export declare function wrapForDiagnostics(expr: ts.Expression): ts.Expression;
-/**
- * Wraps the node in parenthesis such that inserted span comments become attached to the proper
- * node. This is an alias for `ts.factory.createParenthesizedExpression` with the benefit that it
- * signifies that the inserted parenthesis are for use by the type checker, not for correctness of
- * the rendered TCB code.
- */
-export declare function wrapForTypeChecker(expr: ts.Expression): ts.Expression;
-/**
- * Adds a synthetic comment to the expression that represents the parse span of the provided node.
- * This comment can later be retrieved as trivia of a node to recover original source locations.
- */
-export declare function addParseSpanInfo(node: ts.Node, span: AbsoluteSourceSpan | ParseSourceSpan): void;
-/**
- * Adds a synthetic comment to the function declaration that contains the type checking ID
- * of the class declaration.
- */
-export declare function addTypeCheckId(tcb: ts.FunctionDeclaration, id: TypeCheckId): void;
 /**
  * Determines if the diagnostic should be reported. Some diagnostics are produced because of the
  * way TCBs are generated; those diagnostics should not be reported as type check errors of the

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { Reference, ReferenceEmitter } from '../../imports';
-import { ClassDeclaration, ReflectionHost } from '../../reflection';
+import { ReferenceEmitter } from '../../imports';
+import { ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
 import { TcbDirectiveMetadata, TcbPipeMetadata, TcbReferenceKey, TcbReferenceMetadata, TypeCheckingConfig } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
@@ -39,13 +39,6 @@ export declare class Environment extends ReferenceEmitEnvironment {
      */
     typeCtorFor(dir: TcbDirectiveMetadata): TcbExpr;
     pipeInst(pipe: TcbPipeMetadata): TcbExpr;
-    /**
-     * Generate a `ts.Expression` that references the given node.
-     *
-     * This may involve importing the node into the file if it's not declared there already.
-     */
-    reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): TcbExpr;
-    private emitTypeParameters;
     getPreludeStatements(): TcbExpr[];
 }
 export declare function getTcbReferenceKey(ref: TcbReferenceMetadata): TcbReferenceKey;

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { TransplantedType, Type } from '@angular/compiler';
+import { TransplantedType } from '@angular/compiler';
 import ts from 'typescript';
 import { ImportFlags, Reference, ReferenceEmitter } from '../../imports';
 import { ReflectionHost } from '../../reflection';
@@ -31,30 +31,11 @@ export declare class ReferenceEmitEnvironment {
      * This may involve importing the node into the file if it's not declared there already.
      */
     referenceType(ref: Reference, flags?: ImportFlags): ts.TypeNode;
-    /**
-     * Generates a `ts.TypeNode` from a `TcbReferenceMetadata` object.
-     * This is used by the TCB operations which do not hold on to the original `ts.Declaration`.
-     *
-     * Note: It's important that we do not try to evaluate the `typeParameters` here and pad them
-     * out with `any` type arguments. If we supply `any` to a generic pipe (e.g. `var _pipe1: MyPipe<any>;`),
-     * it destroys the generic constraints and degrades the `transform` signature. When they are omitted
-     * entirely, TypeScript implicitly flags an error, which the Angular compiler filters out, and
-     * crucially recovers by falling back to constraint inference (e.g. `var _pipe1: MyPipe;` infers
-     * bounds safely).
-     */
-    referenceTcbType(ref: TcbReferenceMetadata): ts.TypeNode;
     /**
      * Generates a `TcbExpr` from a `TcbReferenceMetadata` object.
      */
     referenceTcbValue(ref: TcbReferenceMetadata): TcbExpr;
     referenceExternalSymbol(moduleName: string, name: string): TcbExpr;
-    /**
-     * Generate a `ts.TypeNode` that references a given type from the provided module.
-     *
-     * This will involve importing the type into the file, and will also add type parameters if
-     * provided.
-     */
-    referenceExternalType(moduleName: string, name: string, typeParams?: Type[]): ts.TypeNode;
     /**
      * Generates a `ts.TypeNode` representing a type that is being referenced from a different place
      * in the program. Any type references inside the transplanted type will be rewritten so that

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

@@ -10,11 +10,12 @@ import { Environment } from './environment';
 import { Reference } from '../../imports';
 import { ClassDeclaration } from '../../reflection';
 import ts from 'typescript';
+import { TcbGenericContextBehavior } from './ops/context';
 /**
  * Adapts the compiler's `TypeCheckBlockMetadata` (which includes full TS AST nodes)
  * into a purely detached `TcbTypeCheckBlockMetadata` that can be mapped to JSON.
  */
-export declare function adaptTypeCheckBlockMetadata(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata, env: Environment): {
+export declare function adaptTypeCheckBlockMetadata(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata, env: Environment, genericContextBehavior: TcbGenericContextBehavior): {
     tcbMeta: TcbTypeCheckBlockMetadata;
     component: TcbComponentMetadata;
 };

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

@@ -7,10 +7,6 @@
  */
 import ts from 'typescript';
 export declare function isAccessExpression(node: ts.Node): node is ts.ElementAccessExpression | ts.PropertyAccessExpression;
-/**
- * Creates a TypeScript node representing a numeric value.
- */
-export declare function tsNumericExpression(value: number): ts.NumericLiteral | ts.PrefixUnaryExpression;
 /**
  * Check if a node represents a directive declaration in a TypeCheck Block.
  * Directive declarations can be either:

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

@@ -5,12 +5,10 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import ts from 'typescript';
 import { TcbComponentMetadata, TcbTypeCheckBlockMetadata } from '../api';
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
-import { TcbGenericContextBehavior } from './ops/context';
 /**
  * Given a `ts.ClassDeclaration` for a component, and metadata regarding that component, compose a
  * "type check block" function.
@@ -26,7 +24,7 @@ import { TcbGenericContextBehavior } from './ops/context';
  *
  * @param env an `Environment` into which type-checking code will be generated.
  * @param ref a `Reference` to the component class which should be type-checked.
- * @param name a `ts.Identifier` to use for the generated `ts.FunctionDeclaration`.
+ * @param name Name of the generated function.
  * @param meta metadata about the component's template and the function being generated.
  * @param domSchemaChecker used to check and record errors regarding improper usage of DOM elements
  * and bindings.
@@ -35,4 +33,4 @@ import { TcbGenericContextBehavior } from './ops/context';
  * @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, component: TcbComponentMetadata, name: ts.Identifier, meta: TcbTypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): string;
+export declare function generateTypeCheckBlock(env: Environment, component: TcbComponentMetadata, name: string, meta: TcbTypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder): string;

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

@@ -33,4 +33,3 @@ export declare class TypeCheckFile extends Environment {
     render(): string;
     getPreludeStatements(): TcbExpr[];
 }
-export declare function typeCheckFilePath(rootDirs: AbsoluteFsPath[]): AbsoluteFsPath;

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

@@ -10,7 +10,7 @@ import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { TypeCtorMetadata, TcbTypeParameter } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 import { TcbExpr } from './ops/codegen';
-export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: TcbTypeParameter[] | undefined): TcbExpr;
+export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: TcbExpr, typeParams: TcbTypeParameter[] | undefined): TcbExpr;
 /**
  * Generate an inline type constructor for the given class and metadata.
  *