@angular/compiler-cli 21.2.0 → 22.0.0-next.0

package/src/ngtsc/typecheck/src/ops/inputs.d.ts

@@ -6,17 +6,17 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST, TmplAstBoundAttribute, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
-import ts from 'typescript';
 import type { Context } from './context';
 import type { Scope } from './scope';
 import { TypeCheckableDirectiveMeta } from '../../api';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { CustomFormControlType } from './signal_forms';
 import { LocalSymbol } from './references';
 /**
  * Translates the given attribute binding to a `ts.Expression`.
  */
-export declare function translateInput(value: AST | string, tcb: Context, scope: Scope): ts.Expression;
+export declare function translateInput(value: AST | string, tcb: Context, scope: Scope): TcbExpr;
 /**
  * A `TcbOp` which generates code to check input bindings on an element that correspond with the
  * members of a directive.

package/src/ngtsc/typecheck/src/ops/let.d.ts

@@ -6,10 +6,10 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstLetDeclaration } from '@angular/compiler';
-import ts from 'typescript';
 import { Context } from './context';
 import type { Scope } from './scope';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 /**
  * A `TcbOp` which generates a constant for a `TmplAstLetDeclaration`.
  *
@@ -25,5 +25,5 @@ export declare class TcbLetDeclarationOp extends TcbOp {
      * should be checked even if they aren't referenced anywhere.
      */
     readonly optional = false;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/references.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstHostElement, TmplAstLetDeclaration, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 import { TypeCheckableDirectiveMeta } from '../../api';
@@ -41,7 +41,7 @@ export declare class TcbReferenceOp extends TcbOp {
     private readonly target;
     constructor(tcb: Context, scope: Scope, node: TmplAstReference, host: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, target: TypeCheckableDirectiveMeta | TmplAstTemplate | TmplAstElement);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which is used when the target of a reference is missing. This operation generates a
@@ -53,5 +53,5 @@ export declare class TcbInvalidReferenceOp extends TcbOp {
     private readonly scope;
     constructor(tcb: Context, scope: Scope);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/schema.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstComponent, TmplAstElement, TmplAstHostElement } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { Context } from './context';
 /**
  * A `TcbOp` which feeds elements and unclaimed properties to the `DomSchemaChecker`.
@@ -26,6 +26,6 @@ export declare class TcbDomSchemaCheckerOp extends TcbOp {
     private claimedInputs;
     constructor(tcb: Context, element: TmplAstElement | TmplAstComponent | TmplAstHostElement, checkElement: boolean, claimedInputs: Set<string> | null);
     get optional(): boolean;
-    execute(): ts.Expression | null;
+    execute(): TcbExpr | null;
     private getTagName;
 }

package/src/ngtsc/typecheck/src/ops/scope.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstForLoopBlock, TmplAstHostElement, TmplAstIfBlockBranch, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
-import ts from 'typescript';
+import { TcbExpr } from './codegen';
 import { TypeCheckableDirectiveMeta } from '../../api';
 import { Context } from './context';
 import { LocalSymbol } from './references';
@@ -30,7 +30,7 @@ export declare class Scope {
     /**
      * A queue of operations which need to be performed to generate the TCB code for this scope.
      *
-     * This array can contain either a `TcbOp` which has yet to be executed, or a `ts.Expression|null`
+     * This array can contain either a `TcbOp` which has yet to be executed, or a `TcbExpr|null`
      * representing the memoized result of executing the operation. As operations are executed, their
      * results are written into the `opQueue`, overwriting the original operation.
      *
@@ -101,7 +101,7 @@ export declare class Scope {
      * @param children Child nodes that should be appended to the TCB.
      * @param guard an expression that is applied to this scope for type narrowing purposes.
      */
-    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: ts.Expression | null): Scope;
+    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: TcbExpr | null): Scope;
     /** Registers a local variable with a scope. */
     private static registerVariable;
     /**
@@ -123,20 +123,20 @@ export declare class Scope {
      * @param directive if present, a directive type on a `TmplAstElement` or `TmplAstTemplate` to
      * look up instead of the default for an element or template node.
      */
-    resolve(node: LocalSymbol, directive?: TypeCheckableDirectiveMeta): ts.Identifier | ts.NonNullExpression;
+    resolve(node: LocalSymbol, directive?: TypeCheckableDirectiveMeta): TcbExpr;
     /**
      * Add a statement to this scope.
      */
-    addStatement(stmt: ts.Statement): void;
+    addStatement(stmt: TcbExpr): void;
     /**
      * Get the statements.
      */
-    render(): ts.Statement[];
+    render(): TcbExpr[];
     /**
      * Returns an expression of all template guards that apply to this scope, including those of
      * parent scopes. If no guards have been applied, null is returned.
      */
-    guards(): ts.Expression | null;
+    guards(): TcbExpr | null;
     /** Returns whether a template symbol is defined locally within the current scope. */
     isLocal(node: TmplAstVariable | TmplAstLetDeclaration | TmplAstReference): boolean;
     /**
@@ -150,10 +150,10 @@ export declare class Scope {
      * @param children Child nodes that should be appended to the TCB.
      * @param guard an expression that is applied to this scope for type narrowing purposes.
      */
-    createChildScope(parentScope: Scope, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: ts.Expression | null): Scope;
+    createChildScope(parentScope: Scope, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: TcbExpr | null): Scope;
     private resolveLocal;
     /**
-     * Like `executeOp`, but assert that the operation actually returned `ts.Expression`.
+     * Like `executeOp`, but assert that the operation actually returned `TcbExpr`.
      */
     private resolveOp;
     /**

package/src/ngtsc/typecheck/src/ops/selectorless.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstComponent } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import { Context } from './context';
 import type { Scope } from './scope';
 export declare function getComponentTagName(node: TmplAstComponent): string;
@@ -22,5 +22,5 @@ export declare class TcbComponentNodeOp extends TcbOp {
     private component;
     readonly optional = true;
     constructor(tcb: Context, scope: Scope, component: TmplAstComponent);
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/template.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstTemplate } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
+import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
 /**
@@ -20,7 +20,7 @@ export declare class TcbTemplateContextOp extends TcbOp {
     private scope;
     constructor(tcb: Context, scope: Scope);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which descends into a `TmplAstTemplate`'s children and generates type-checking code for

package/src/ngtsc/typecheck/src/ops/variables.d.ts

@@ -6,10 +6,10 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
-import ts from 'typescript';
 import { TcbOp } from './base';
 import type { Context } from './context';
 import type { Scope } from './scope';
+import { TcbExpr } from './codegen';
 /**
  * A `TcbOp` which renders a variable that is implicitly available within a block (e.g. `$count`
  * in a `@for` block).
@@ -21,9 +21,9 @@ export declare class TcbBlockImplicitVariableOp extends TcbOp {
     private scope;
     private type;
     private variable;
-    constructor(tcb: Context, scope: Scope, type: ts.TypeNode, variable: TmplAstVariable);
+    constructor(tcb: Context, scope: Scope, type: TcbExpr, variable: TmplAstVariable);
     readonly optional = true;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which creates an expression for particular let- `TmplAstVariable` on a
@@ -38,7 +38,7 @@ export declare class TcbTemplateVariableOp extends TcbOp {
     private variable;
     constructor(tcb: Context, scope: Scope, template: TmplAstTemplate, variable: TmplAstVariable);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }
 /**
  * A `TcbOp` which renders a variable defined inside of block syntax (e.g. `@if (expr; as var) {}`).
@@ -50,7 +50,7 @@ export declare class TcbBlockVariableOp extends TcbOp {
     private scope;
     private initializer;
     private variable;
-    constructor(tcb: Context, scope: Scope, initializer: ts.Expression, variable: TmplAstVariable);
+    constructor(tcb: Context, scope: Scope, initializer: TcbExpr, variable: TmplAstVariable);
     get optional(): boolean;
-    execute(): ts.Identifier;
+    execute(): TcbExpr;
 }

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

@@ -10,6 +10,7 @@ import ts from 'typescript';
 import { ImportFlags, Reference, ReferenceEmitter } from '../../imports';
 import { ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
+import { TcbExpr } from './ops/codegen';
 /**
  * An environment for a given source file that can be used to emit references.
  *
@@ -29,11 +30,7 @@ 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;
-    /**
-     * Generate a `ts.Expression` that refers to the external symbol. This
-     * may result in new imports being generated.
-     */
-    referenceExternalSymbol(moduleName: string, name: string): ts.Expression;
+    referenceExternalSymbol(moduleName: string, name: string): TcbExpr;
     /**
      * Generate a `ts.TypeNode` that references a given type from the provided module.
      *

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

@@ -6,43 +6,6 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-export declare function tsCastToAny(expr: ts.Expression): ts.Expression;
-/**
- * Create an expression which instantiates an element by its HTML tagName.
- *
- * Thanks to narrowing of `document.createElement()`, this expression will have its type inferred
- * based on the tag name, including for custom elements that have appropriate .d.ts definitions.
- */
-export declare function tsCreateElement(...tagNames: string[]): ts.Expression;
-/**
- * Create a `ts.VariableStatement` which declares a variable without explicit initialization.
- *
- * The initializer `null!` is used to bypass strict variable initialization checks.
- *
- * Unlike with `tsCreateVariable`, the type of the variable is explicitly specified.
- */
-export declare function tsDeclareVariable(id: ts.Identifier, type: ts.TypeNode): ts.VariableStatement;
-/**
- * Creates a `ts.TypeQueryNode` for a coerced input.
- *
- * For example: `typeof MatInput.ngAcceptInputType_value`, where MatInput is `typeName` and `value`
- * is the `coercedInputName`.
- *
- * @param typeName The `EntityName` of the Directive where the static coerced input is defined.
- * @param coercedInputName The field name of the coerced input.
- */
-export declare function tsCreateTypeQueryForCoercedInput(typeName: ts.EntityName, coercedInputName: string): ts.TypeQueryNode;
-/**
- * Create a `ts.VariableStatement` that initializes a variable with a given expression.
- *
- * Unlike with `tsDeclareVariable`, the type of the variable is inferred from the initializer
- * expression.
- */
-export declare function tsCreateVariable(id: ts.Identifier, initializer: ts.Expression, flags?: ts.NodeFlags | null): ts.VariableStatement;
-/**
- * Construct a `ts.CallExpression` that calls a method on a receiver.
- */
-export declare function tsCallMethod(receiver: ts.Expression, methodName: string, args?: ts.Expression[]): ts.CallExpression;
 export declare function isAccessExpression(node: ts.Node): node is ts.ElementAccessExpression | ts.PropertyAccessExpression;
 /**
  * Creates a TypeScript node representing a numeric value.

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

@@ -37,4 +37,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, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): ts.FunctionDeclaration;
+export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): string;

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

@@ -14,6 +14,7 @@ import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
 import { TcbGenericContextBehavior } from './ops/context';
+import { TcbExpr } from './ops/codegen';
 /**
  * An `Environment` representing the single type-checking file into which most (if not all) Type
  * Check Blocks (TCBs) will be generated.
@@ -28,7 +29,7 @@ export declare class TypeCheckFile extends Environment {
     private tcbStatements;
     constructor(fileName: AbsoluteFsPath, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>);
     addTypeCheckBlock(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): void;
-    render(removeComments: boolean): string;
-    getPreludeStatements(): ts.Statement[];
+    render(): string;
+    getPreludeStatements(): TcbExpr[];
 }
 export declare function typeCheckFilePath(rootDirs: AbsoluteFsPath[]): AbsoluteFsPath;

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

@@ -9,7 +9,8 @@ import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { TypeCtorMetadata } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
-export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined): ts.Statement;
+import { TcbExpr } from './ops/codegen';
+export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined): TcbExpr;
 /**
  * Generate an inline type constructor for the given class and metadata.
  *
@@ -45,5 +46,5 @@ export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironm
  * @param meta additional metadata required to generate the type constructor.
  * @returns a `ts.MethodDeclaration` for the type constructor.
  */
-export declare function generateInlineTypeCtor(env: ReferenceEmitEnvironment, node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): ts.MethodDeclaration;
+export declare function generateInlineTypeCtor(env: ReferenceEmitEnvironment, node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): string;
 export declare function requiresInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost, env: ReferenceEmitEnvironment): boolean;