@angular/compiler-cli 22.0.0-next.2 → 22.0.0-next.4

package/linker/src/file_linker/emit_scopes/local_emit_scope.d.ts

@@ -12,7 +12,7 @@ import { EmitScope } from './emit_scope';
  * there is no clear shared scope for constant statements. In this case they are bundled with the
  * translated definition and will be emitted into an IIFE.
  */
-export declare class LocalEmitScope<TStatement, TExpression> extends EmitScope<TStatement, TExpression> {
+export declare class LocalEmitScope<TStatement, TExpression, TType> extends EmitScope<TStatement, TExpression, TType> {
     /**
      * Translate the given Output AST definition expression into a generic `TExpression`.
      *

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

@@ -5,11 +5,11 @@ export declare const NO_STATEMENTS: Readonly<any[]>;
 /**
  * This class is responsible for linking all the partial declarations found in a single file.
  */
-export declare class FileLinker<TConstantScope, TStatement, TExpression> {
+export declare class FileLinker<TConstantScope, TStatement, TExpression, TType> {
     private linkerEnvironment;
     private linkerSelector;
     private emitScopes;
-    constructor(linkerEnvironment: LinkerEnvironment<TStatement, TExpression>, sourceUrl: AbsoluteFsPath, code: string);
+    constructor(linkerEnvironment: LinkerEnvironment<TStatement, TExpression, TType>, sourceUrl: AbsoluteFsPath, code: string);
     /**
      * Return true if the given callee name matches a partial declaration that can be linked.
      */

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 = "22.0.0-next.2";
+export declare const PLACEHOLDER_VERSION = "22.0.0-next.4";
 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": "22.0.0-next.2",
+  "version": "22.0.0-next.4",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -43,7 +43,7 @@
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "@angular/compiler": "22.0.0-next.2",
+    "@angular/compiler": "22.0.0-next.4",
     "typescript": ">=5.9 <6.1"
   },
   "peerDependenciesMeta": {

package/src/ngtsc/file_system/testing/index.d.ts

@@ -9,4 +9,4 @@ export { Folder, MockFileSystem } from './src/mock_file_system';
 export { MockFileSystemNative } from './src/mock_file_system_native';
 export { MockFileSystemPosix } from './src/mock_file_system_posix';
 export { MockFileSystemWindows } from './src/mock_file_system_windows';
-export { initMockFileSystem, runInEachFileSystem, TestFile } from './src/test_helper';
+export { initMockFileSystem, lockMockFileSystem, runInEachFileSystem, TestFile, } from './src/test_helper';

package/src/ngtsc/file_system/testing/src/test_helper.d.ts

@@ -13,4 +13,5 @@ export interface RunInEachFileSystemFn {
     osX(callback: (os: string) => void): void;
 }
 export declare const runInEachFileSystem: RunInEachFileSystemFn;
+export declare function lockMockFileSystem(): void;
 export declare function initMockFileSystem(os: string, cwd?: AbsoluteFsPath): MockFileSystem;

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/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/type_check_block.d.ts

@@ -9,7 +9,6 @@ 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.
@@ -34,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: string, 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;