@angular/compiler-cli 17.1.0-rc.0 → 17.1.0

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 = "17.1.0-rc.0";
+export declare const PLACEHOLDER_VERSION = "17.1.0";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "17.1.0-rc.0",
+  "version": "17.1.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -53,7 +53,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "17.1.0-rc.0",
+    "@angular/compiler": "17.1.0",
     "typescript": ">=5.2 <5.4"
   },
   "repository": {

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -88,7 +88,21 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     updateResources(node: ClassDeclaration, analysis: ComponentAnalysisData): void;
     compileFull(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, resolution: Readonly<ComponentResolutionData>, pool: ConstantPool): CompileResult[];
     compilePartial(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, resolution: Readonly<ComponentResolutionData>): CompileResult[];
-    compileLocal(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, pool: ConstantPool): CompileResult[];
+    compileLocal(node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>, resolution: Readonly<Partial<ComponentResolutionData>>, pool: ConstantPool): CompileResult[];
+    /**
+     * Locates defer blocks in case scope information is not available.
+     * For example, this happens in the local compilation mode.
+     */
+    private locateDeferBlocksWithoutScope;
+    /**
+     * Computes a list of deferrable symbols based on dependencies from
+     * the `@Component.imports` field and their usage in `@defer` blocks.
+     */
+    private collectDeferredSymbols;
+    /**
+     * Collects deferrable symbols from the `@Component.deferredImports` field.
+     */
+    private collectExplicitlyDeferredSymbols;
     /**
      * Check whether adding an import from `origin` to the source-file corresponding to `expr` would
      * create a cyclic import.
@@ -102,6 +116,12 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
      * available for the final `compile` step.
      */
     private resolveDeferBlocks;
+    /**
+     * Inspects provided imports expression (either `@Component.imports` or
+     * `@Component.deferredImports`) and registers imported types as deferrable
+     * candidates.
+     */
+    private registerDeferrableCandidates;
     /** Resolves the triggers of the defer block to the elements that they're pointing to. */
     private resolveDeferTriggers;
 }

package/src/ngtsc/annotations/component/src/metadata.d.ts

@@ -18,7 +18,7 @@ import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
  * The `keyof R3ComponentMetadata &` condition ensures that only fields of `R3ComponentMetadata` can
  * be included here.
  */
-export type ComponentMetadataResolvedFields = SubsetOfKeys<R3ComponentMetadata<R3TemplateDependencyMetadata>, 'declarations' | 'declarationListEmitMode' | 'deferBlocks' | 'deferrableDeclToImportDecl'>;
+export type ComponentMetadataResolvedFields = SubsetOfKeys<R3ComponentMetadata<R3TemplateDependencyMetadata>, 'declarations' | 'declarationListEmitMode' | 'deferBlocks' | 'deferrableDeclToImportDecl' | 'deferrableTypes' | 'deferBlockDepsEmitMode'>;
 export interface ComponentAnalysisData {
     /**
      * `meta` includes those fields of `R3ComponentMetadata` which are calculated at `analyze` time
@@ -55,6 +55,12 @@ export interface ComponentAnalysisData {
     animationTriggerNames: AnimationTriggerNames | null;
     rawImports: ts.Expression | null;
     resolvedImports: Reference<ClassDeclaration>[] | null;
+    rawDeferredImports: ts.Expression | null;
+    resolvedDeferredImports: Reference<ClassDeclaration>[] | null;
+    /**
+     * Map of symbol name -> import path for types from `@Component.deferredImports` field.
+     */
+    explicitlyDeferredTypes: Map<string, string> | null;
     schemas: SchemaMetadata[] | null;
     decorator: ts.Decorator | null;
     /** Additional directives applied to the component host. */

package/src/ngtsc/annotations/component/src/util.d.ts

@@ -19,7 +19,7 @@ import { ClassDeclaration } from '../../../reflection';
 export declare function collectAnimationNames(value: ResolvedValue, animationTriggerNames: AnimationTriggerNames): void;
 export declare function isAngularAnimationsReference(reference: Reference, symbolName: string): boolean;
 export declare const animationTriggerResolver: ForeignFunctionResolver;
-export declare function validateAndFlattenComponentImports(imports: ResolvedValue, expr: ts.Expression): {
+export declare function validateAndFlattenComponentImports(imports: ResolvedValue, expr: ts.Expression, isDeferred: boolean): {
     imports: Reference<ClassDeclaration>[];
     diagnostics: ts.Diagnostic[];
 };

package/src/ngtsc/annotations/directive/src/handler.d.ts

@@ -57,7 +57,7 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     resolve(node: ClassDeclaration, analysis: DirectiveHandlerData, symbol: DirectiveSymbol): ResolveResult<unknown>;
     compileFull(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[];
     compilePartial(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>): CompileResult[];
-    compileLocal(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, pool: ConstantPool): CompileResult[];
+    compileLocal(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[];
     /**
      * Checks if a given class uses Angular features and returns the TypeScript node
      * that indicated the usage. Classes are considered using Angular features if they

package/src/ngtsc/annotations/src/injectable.d.ts

@@ -50,7 +50,7 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator>): AnalysisOutput<InjectableHandlerData>;
     symbol(): null;
     register(node: ClassDeclaration, analysis: InjectableHandlerData): void;
-    resolve(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>, symbol: null): ResolveResult<unknown>;
+    resolve(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): ResolveResult<unknown>;
     compileFull(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
     compilePartial(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
     compileLocal(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];

package/src/ngtsc/core/api/src/public_options.d.ts

@@ -292,6 +292,16 @@ export interface BazelAndG3Options {
      * Insert JSDoc type annotations needed by Closure Compiler
      */
     annotateForClosureCompiler?: boolean;
+    /**
+     * Specifies whether Angular compiler should rely on explicit imports
+     * via `@Component.deferredImports` field for `@defer` blocks and generate
+     * dynamic imports only for types from that list.
+     *
+     * This flag is needed to enable stricter behavior internally to make sure
+     * that local compilation with specific internal configuration can support
+     * `@defer` blocks.
+     */
+    onlyExplicitDeferDependencyImports?: boolean;
 }
 /**
  * Options related to i18n compilation support.

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

@@ -100,6 +100,11 @@ export declare enum ErrorCode {
     CONFLICTING_INPUT_TRANSFORM = 2020,
     /** Raised when a component has both `styleUrls` and `styleUrl`. */
     COMPONENT_INVALID_STYLE_URLS = 2021,
+    /**
+     * Raised when a type in the `deferredImports` of a component is not a component, directive or
+     * pipe.
+     */
+    COMPONENT_UNKNOWN_DEFERRED_IMPORT = 2022,
     SYMBOL_NOT_EXPORTED = 3001,
     /**
      * Raised when a relationship between directives and/or pipes would cause a cyclic import to be
@@ -258,6 +263,21 @@ export declare enum ErrorCode {
      * ```
      */
     CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION = 8011,
+    /**
+     * A pipe imported via `@Component.deferredImports` is
+     * used outside of a `@defer` block in a template.
+     */
+    DEFERRED_PIPE_USED_EAGERLY = 8012,
+    /**
+     * A directive/component imported via `@Component.deferredImports` is
+     * used outside of a `@defer` block in a template.
+     */
+    DEFERRED_DIRECTIVE_USED_EAGERLY = 8013,
+    /**
+     * A directive/component/pipe imported via `@Component.deferredImports` is
+     * also included into the `@Component.imports` list.
+     */
+    DEFERRED_DEPENDENCY_IMPORTED_EAGERLY = 8014,
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:

package/src/ngtsc/imports/src/deferred_symbol_tracker.d.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
+import { ClassDeclaration } from '../../reflection';
 /**
  * Allows to register a symbol as deferrable and keep track of its usage.
  *
@@ -15,8 +16,14 @@ import ts from 'typescript';
  */
 export declare class DeferredSymbolTracker {
     private readonly typeChecker;
+    private onlyExplicitDeferDependencyImports;
     private readonly imports;
-    constructor(typeChecker: ts.TypeChecker);
+    /**
+     * Map of a component class -> all import declarations that bring symbols
+     * used within `@Component.deferredImports` field.
+     */
+    private readonly explicitlyDeferredImports;
+    constructor(typeChecker: ts.TypeChecker, onlyExplicitDeferDependencyImports: boolean);
     /**
      * Given an import declaration node, extract the names of all imported symbols
      * and return them as a map where each symbol is a key and `AssumeEager` is a value.
@@ -28,11 +35,18 @@ export declare class DeferredSymbolTracker {
      * Case 3: `import * as x from 'a'`
      */
     private extractImportedSymbols;
+    /**
+     * Retrieves a list of import declarations that contain symbols used within
+     * `@Component.deferredImports` of a specific component class, but those imports
+     * can not be removed, since there are other symbols imported alongside deferred
+     * components.
+     */
+    getNonRemovableDeferredImports(sourceFile: ts.SourceFile, classDecl: ClassDeclaration): ts.ImportDeclaration[];
     /**
      * Marks a given identifier and an associated import declaration as a candidate
      * for defer loading.
      */
-    markAsDeferrableCandidate(identifier: ts.Identifier, importDecl: ts.ImportDeclaration): void;
+    markAsDeferrableCandidate(identifier: ts.Identifier, importDecl: ts.ImportDeclaration, componentClassDecl: ClassDeclaration, isExplicitlyDeferred: boolean): void;
     /**
      * Whether all symbols from a given import declaration have no references
      * in a source file, thus it's safe to use dynamic imports.

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

@@ -192,6 +192,11 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * For standalone components, the list of imported types.
      */
     imports: Reference<ClassDeclaration>[] | null;
+    /**
+     * For standalone components, the list of imported types that can be used
+     * in `@defer` blocks (when only explicit dependencies are allowed).
+     */
+    deferredImports: Reference<ClassDeclaration>[] | null;
     /**
      * For standalone components, the list of schemas declared.
      */
@@ -208,6 +213,11 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * Whether the directive should be assumed to export providers if imported as a standalone type.
      */
     assumedToExportProviders: boolean;
+    /**
+     * Whether this class was imported into a standalone component's
+     * scope via `@Component.deferredImports` field.
+     */
+    isExplicitlyDeferred: boolean;
 }
 /** Metadata collected about an additional directive that is being applied to a directive host. */
 export interface HostDirectiveMeta {
@@ -251,6 +261,7 @@ export interface PipeMeta {
     nameExpr: ts.Expression | null;
     isStandalone: boolean;
     decorator: ts.Decorator | null;
+    isExplicitlyDeferred: boolean;
 }
 /**
  * Reads metadata for directives, pipes, and modules from a particular source, such as .d.ts files

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

@@ -58,6 +58,7 @@ export interface LocalModuleScope extends ExportScope {
 export interface StandaloneScope {
     kind: ComponentScopeKind.Standalone;
     dependencies: Array<DirectiveMeta | PipeMeta | NgModuleMeta>;
+    deferredDependencies: Array<DirectiveMeta | PipeMeta>;
     component: ClassDeclaration;
     schemas: SchemaMetadata[];
     isPoisoned: boolean;

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

@@ -6,9 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { SchemaMetadata, SelectorMatcher } from '@angular/compiler';
-import ts from 'typescript';
 import { Reference } from '../../imports';
-import { DirectiveMeta, HostDirectivesResolver, MetadataReader } from '../../metadata';
+import { DirectiveMeta, HostDirectivesResolver, MetadataReader, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 import { ComponentScopeReader } from './api';
 /**
@@ -27,7 +26,7 @@ export interface TypeCheckScope {
     /**
      * The pipes that are available in the compilation scope.
      */
-    pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;
+    pipes: Map<string, PipeMeta>;
     /**
      * The schemas that are used in this scope.
      */
@@ -62,4 +61,5 @@ export declare class TypeCheckScopeRegistry {
      */
     getTypeCheckScope(node: ClassDeclaration): TypeCheckScope;
     getTypeCheckDirectiveMetadata(ref: Reference<ClassDeclaration>): DirectiveMeta | null;
+    private applyExplicitlyDeferredFlag;
 }

package/src/ngtsc/scope/src/util.d.ts

@@ -12,3 +12,4 @@ import { ComponentScopeReader } from './api';
 export declare function getDiagnosticNode(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null): ts.Expression;
 export declare function makeNotStandaloneDiagnostic(scopeReader: ComponentScopeReader, ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null, kind: 'component' | 'directive' | 'pipe'): ts.Diagnostic;
 export declare function makeUnknownComponentImportDiagnostic(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression): ts.DiagnosticWithLocation;
+export declare function makeUnknownComponentDeferredImportDiagnostic(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression): ts.DiagnosticWithLocation;

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

@@ -167,7 +167,7 @@ export interface DecoratorHandler<D, A, S extends SemanticSymbol | null, R> {
      * Generates code based on each individual source file without using its
      * dependencies (suitable for local dev edit/refresh workflow)
      */
-    compileLocal(node: ClassDeclaration, analysis: Readonly<A>, constantPool: ConstantPool): CompileResult | CompileResult[];
+    compileLocal(node: ClassDeclaration, analysis: Readonly<A>, resolution: Readonly<Partial<R>>, constantPool: ConstantPool): CompileResult | CompileResult[];
 }
 /**
  * The output of detecting a trait for a declaration as the result of the first phase of the

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

@@ -9,7 +9,7 @@ import { AbsoluteSourceSpan, BoundTarget, DirectiveMeta, ParseSourceSpan, Schema
 import ts from 'typescript';
 import { ErrorCode } from '../../diagnostics';
 import { Reference } from '../../imports';
-import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping } from '../../metadata';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 /**
  * Extension of `DirectiveMeta` that includes additional information required to type-check the
@@ -24,6 +24,7 @@ export interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveType
     isSignal: boolean;
     hostDirectives: HostDirectiveMeta[] | null;
     decorator: ts.Decorator | null;
+    isExplicitlyDeferred: boolean;
 }
 export type TemplateId = string & {
     __brand: 'TemplateId';
@@ -63,7 +64,7 @@ export interface TypeCheckBlockMetadata {
      * Semantic information about the template of the component.
      */
     boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
-    pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;
+    pipes: Map<string, PipeMeta>;
     /**
      * Schemas that apply to this template.
      */

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

@@ -8,6 +8,7 @@
 import { ParseError, ParseSourceFile, R3TargetBinder, SchemaMetadata, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
+import { PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 import { TemplateSourceMapping, TypeCheckableDirectiveMeta } from './api';
 /**
@@ -36,7 +37,7 @@ export interface TypeCheckContext {
      * @param preserveWhitespaces a boolean indicating whether the component's template preserves
      * whitespaces.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: boolean): void;
+    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: boolean): void;
 }
 /**
  * Interface to trigger generation of type-checking code for a program given a new

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

@@ -9,6 +9,7 @@ import { BoundTarget, ParseError, ParseSourceFile, R3TargetBinder, SchemaMetadat
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { Reference, ReferenceEmitter } from '../../imports';
+import { PipeMeta } from '../../metadata';
 import { PerfRecorder } from '../../perf';
 import { FileUpdate } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
@@ -166,7 +167,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
      *
      * Implements `TypeCheckContext.addTemplate`.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: boolean): void;
+    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: boolean): void;
     /**
      * Record a type constructor for the given `node` with the given `ctorMetadata`.
      */

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

@@ -39,6 +39,24 @@ export interface OutOfBandDiagnosticRecorder {
      * @param ast the `BindingPipe` invocation of the pipe which could not be found.
      */
     missingPipe(templateId: TemplateId, ast: BindingPipe): void;
+    /**
+     * Reports usage of a pipe imported via `@Component.deferredImports` outside
+     * of a `@defer` block in a template.
+     *
+     * @param templateId the template type-checking ID of the template which contains the unknown
+     * pipe.
+     * @param ast the `BindingPipe` invocation of the pipe which could not be found.
+     */
+    deferredPipeUsedEagerly(templateId: TemplateId, ast: BindingPipe): void;
+    /**
+     * Reports usage of a component/directive imported via `@Component.deferredImports` outside
+     * of a `@defer` block in a template.
+     *
+     * @param templateId the template type-checking ID of the template which contains the unknown
+     * pipe.
+     * @param element the element which hosts a component that was defer-loaded.
+     */
+    deferredComponentUsedEagerly(templateId: TemplateId, element: TmplAstElement): void;
     illegalAssignmentToTemplateVar(templateId: TemplateId, assignment: PropertyWrite, target: TmplAstVariable): void;
     /**
      * Reports a duplicate declaration of a template variable.
@@ -87,6 +105,8 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
     missingReferenceTarget(templateId: TemplateId, ref: TmplAstReference): void;
     missingPipe(templateId: TemplateId, ast: BindingPipe): void;
+    deferredPipeUsedEagerly(templateId: TemplateId, ast: BindingPipe): void;
+    deferredComponentUsedEagerly(templateId: TemplateId, element: TmplAstElement): void;
     illegalAssignmentToTemplateVar(templateId: TemplateId, assignment: PropertyWrite, target: TmplAstVariable): void;
     duplicateTemplateVar(templateId: TemplateId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
     requiresInlineTcb(templateId: TemplateId, node: ClassDeclaration): void;

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

@@ -8,6 +8,7 @@
 import { BoundTarget, SchemaMetadata, TmplAstElement, TmplAstForLoopBlock, TmplAstIfBlockBranch, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
+import { PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 import { TemplateId, TypeCheckableDirectiveMeta, TypeCheckBlockMetadata } from '../api';
 import { DomSchemaChecker } from './dom';
@@ -131,7 +132,7 @@ export declare class Context {
     readonly hostIsStandalone: boolean;
     readonly hostPreserveWhitespaces: boolean;
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
     /**
      * Allocate a new variable name for use within the `Context`.
      *
@@ -139,7 +140,7 @@ export declare class Context {
      * might change depending on the type of data being stored.
      */
     allocateId(): ts.Identifier;
-    getPipeByName(name: string): Reference<ClassDeclaration<ts.ClassDeclaration>> | null;
+    getPipeByName(name: string): PipeMeta | null;
 }
 /**
  * Local scope within the type check block for a particular template.