@angular/compiler-cli 13.1.1 → 13.1.2

package/index.d.ts

@@ -10,3 +10,5 @@ export * from './src/ngtsc/file_system';
 export { NgTscPlugin } from './src/ngtsc/tsc_plugin';
 export { NgtscProgram } from './src/ngtsc/program';
 export { OptimizeFor } from './src/ngtsc/typecheck/api';
+export { ConsoleLogger, Logger, LogLevel } from './src/ngtsc/logging';
+export { NodeJSFileSystem } from './src/ngtsc/file_system';

package/ngcc/src/packages/build_marker.d.ts

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "13.1.1";
+export declare const NGCC_VERSION = "13.1.2";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "13.1.1",
+  "version": "13.1.2",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -66,7 +66,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "13.1.1",
+    "@angular/compiler": "13.1.2",
     "typescript": ">=4.4.2 <4.6"
   },
   "repository": {

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

@@ -50,7 +50,7 @@ export declare function getValidConstructorDependencies(clazz: ClassDeclaration,
  * deps.
  */
 export declare function validateConstructorDependencies(clazz: ClassDeclaration, deps: ConstructorDeps | null): R3DependencyMetadata[] | null;
-export declare function toR3Reference(valueRef: Reference, typeRef: Reference, valueContext: ts.SourceFile, typeContext: ts.SourceFile, refEmitter: ReferenceEmitter): R3Reference;
+export declare function toR3Reference(origin: ts.Node, valueRef: Reference, typeRef: Reference, valueContext: ts.SourceFile, typeContext: ts.SourceFile, refEmitter: ReferenceEmitter): R3Reference;
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
 };

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

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/core/api/src/options" />
 import ts from 'typescript';
-import { BazelAndG3Options, I18nOptions, LegacyNgcOptions, MiscOptions, NgcCompatibilityOptions, StrictTemplateOptions, TargetOptions } from './public_options';
+import { BazelAndG3Options, DiagnosticOptions, I18nOptions, LegacyNgcOptions, MiscOptions, NgcCompatibilityOptions, StrictTemplateOptions, TargetOptions } from './public_options';
 /**
  * Non-public options which are useful during testing of the compiler.
  */
@@ -37,5 +37,6 @@ export interface InternalOptions {
  *
  * Also includes a few miscellaneous options.
  */
-export interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options, NgcCompatibilityOptions, StrictTemplateOptions, TestOnlyOptions, I18nOptions, TargetOptions, InternalOptions, MiscOptions {
+export interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options, DiagnosticOptions, NgcCompatibilityOptions, StrictTemplateOptions, TestOnlyOptions, I18nOptions, TargetOptions, InternalOptions, MiscOptions {
+    [prop: string]: any;
 }

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

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/core/api/src/public_options" />
+import { ExtendedTemplateDiagnosticName } from '../../../../ngtsc/diagnostics';
 /**
  * Options supported by the legacy View Engine compiler, which are still consumed by the Angular Ivy
  * compiler for backwards compatibility.
@@ -237,6 +238,43 @@ export interface StrictTemplateOptions {
      */
     strictLiteralTypes?: boolean;
 }
+/**
+ * A label referring to a `ts.DiagnosticCategory` or `'suppress'`, meaning the associated diagnostic
+ * should not be displayed at all.
+ *
+ * @publicApi
+ */
+export declare enum DiagnosticCategoryLabel {
+    /** Treat the diagnostic as a warning, don't fail the compilation. */
+    Warning = "warning",
+    /** Treat the diagnostic as a hard error, fail the compilation. */
+    Error = "error",
+    /** Ignore the diagnostic altogether. */
+    Suppress = "suppress"
+}
+/**
+ * Options which control how diagnostics are emitted from the compiler.
+ *
+ * @publicApi
+ */
+export interface DiagnosticOptions {
+    /** Options which control how diagnostics are emitted from the compiler. */
+    extendedDiagnostics?: {
+        /**
+         * The category to use for configurable diagnostics which are not overridden by `checks`. Uses
+         * `warning` by default.
+         */
+        defaultCategory?: DiagnosticCategoryLabel;
+        /**
+         * A map of each extended template diagnostic's name to its category. This can be expanded in
+         * the future with more information for each check or for additional diagnostics not part of the
+         * extended template diagnostics system.
+         */
+        checks?: {
+            [Name in ExtendedTemplateDiagnosticName]?: DiagnosticCategoryLabel;
+        };
+    };
+}
 /**
  * Options which control behavior useful for "monorepo" build cases using Bazel (such as the
  * internal Google monorepo, g3).

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

@@ -7,7 +7,8 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics" />
 export { COMPILER_ERRORS_WITH_GUIDES } from './src/docs';
-export { FatalDiagnosticError, isFatalDiagnosticError, makeDiagnostic, makeRelatedInformation } from './src/error';
+export { FatalDiagnosticError, isFatalDiagnosticError, makeDiagnostic, makeDiagnosticChain, makeRelatedInformation } from './src/error';
 export { ErrorCode } from './src/error_code';
 export { ERROR_DETAILS_PAGE_BASE_URL } from './src/error_details_base_url';
+export { ExtendedTemplateDiagnosticName } from './src/extended_template_diagnostic_name';
 export { ngErrorCode, replaceTsWithNgInErrors } from './src/util';

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

@@ -17,5 +17,6 @@ export declare class FatalDiagnosticError {
     toDiagnostic(): ts.DiagnosticWithLocation;
 }
 export declare function makeDiagnostic(code: ErrorCode, node: ts.Node, messageText: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[]): ts.DiagnosticWithLocation;
+export declare function makeDiagnosticChain(messageText: string, next?: ts.DiagnosticMessageChain[]): ts.DiagnosticMessageChain;
 export declare function makeRelatedInformation(node: ts.Node, messageText: string): ts.DiagnosticRelatedInformation;
 export declare function isFatalDiagnosticError(err: any): err is FatalDiagnosticError;

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

@@ -54,8 +54,15 @@ export declare enum ErrorCode {
      * created that cannot be handled, such as in partial compilation mode.
      */
     IMPORT_CYCLE_DETECTED = 3003,
+    /**
+     * Raised when the compiler is unable to generate an import statement for a reference.
+     */
+    IMPORT_GENERATION_FAILURE = 3004,
     CONFIG_FLAT_MODULE_NO_INDEX = 4001,
     CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,
+    CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES = 4003,
+    CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL = 4004,
+    CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK = 4005,
     /**
      * Raised when a host expression has a parse error, such as a host listener or host binding
      * expression containing a pipe.

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

@@ -11,6 +11,6 @@
  *
  * Keep the files below in full sync:
  *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
- *  - packages/core/src/render3/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
  */
 export declare const ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name" />
+/**
+ * Enum holding the name of each extended template diagnostic. The name is used as a user-meaningful
+ * value for configuring the diagnostic in the project's options.
+ *
+ * See the corresponding `ErrorCode` for documentation about each specific error.
+ * packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.ts
+ *
+ * @publicApi
+ */
+export declare enum ExtendedTemplateDiagnosticName {
+    INVALID_BANANA_IN_BOX = "invalidBananaInBox",
+    NULLISH_COALESCING_NOT_NULLABLE = "nullishCoalescingNotNullable"
+}

package/src/ngtsc/file_system/src/compiler_host.d.ts

@@ -22,4 +22,5 @@ export declare class NgtscCompilerHost implements ts.CompilerHost {
     getNewLine(): string;
     fileExists(fileName: string): boolean;
     readFile(fileName: string): string | undefined;
+    realpath(path: string): string;
 }

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

@@ -9,7 +9,7 @@
 export { AliasingHost, AliasStrategy, PrivateExportAliasingHost, UnifiedModulesAliasingHost } from './src/alias';
 export { ImportRewriter, NoopImportRewriter, R3SymbolsImportRewriter, validateAndRewriteCoreSymbol } from './src/core';
 export { DefaultImportTracker } from './src/default';
-export { AbsoluteModuleStrategy, EmittedReference, ImportedFile, ImportFlags, LocalIdentifierStrategy, LogicalProjectStrategy, ReferenceEmitStrategy, ReferenceEmitter, RelativePathStrategy, UnifiedModulesStrategy } from './src/emitter';
+export { AbsoluteModuleStrategy, assertSuccessfulReferenceEmit, EmittedReference, FailedEmitResult, ImportedFile, ImportFlags, LocalIdentifierStrategy, LogicalProjectStrategy, ReferenceEmitKind, ReferenceEmitResult, ReferenceEmitStrategy, ReferenceEmitter, RelativePathStrategy, UnifiedModulesStrategy } from './src/emitter';
 export { Reexport } from './src/reexport';
 export { OwningModule, Reference } from './src/references';
 export { ModuleResolver } from './src/resolver';

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

@@ -51,11 +51,16 @@ export declare enum ImportFlags {
  * an import then `null` should be used.
  */
 export declare type ImportedFile = ts.SourceFile | 'unknown' | null;
+export declare const enum ReferenceEmitKind {
+    Success = 0,
+    Failed = 1
+}
 /**
  * Represents the emitted expression of a `Reference` that is valid in the source file it was
  * emitted from.
  */
 export interface EmittedReference {
+    kind: ReferenceEmitKind.Success;
     /**
      * The expression that refers to `Reference`.
      */
@@ -68,6 +73,33 @@ export interface EmittedReference {
      */
     importedFile: ImportedFile;
 }
+/**
+ * Represents a failure to emit a `Reference` into a different source file.
+ */
+export interface FailedEmitResult {
+    kind: ReferenceEmitKind.Failed;
+    /**
+     * The reference that could not be emitted.
+     */
+    ref: Reference;
+    /**
+     * The source file into which the reference was requested to be emitted.
+     */
+    context: ts.SourceFile;
+    /**
+     * Describes why the reference could not be emitted. This may be shown in a diagnostic.
+     */
+    reason: string;
+}
+export declare type ReferenceEmitResult = EmittedReference | FailedEmitResult;
+/**
+ * Verifies that a reference was emitted successfully, or raises a `FatalDiagnosticError` otherwise.
+ * @param result The emit result that should have been successful.
+ * @param origin The node that is used to report the failure diagnostic.
+ * @param typeKind The kind of the symbol that the reference represents, e.g. 'component' or
+ *     'class'.
+ */
+export declare function assertSuccessfulReferenceEmit(result: ReferenceEmitResult, origin: ts.Node, typeKind: string): asserts result is EmittedReference;
 /**
  * A particular strategy for generating an expression which refers to a `Reference`.
  *
@@ -91,7 +123,7 @@ export interface ReferenceEmitStrategy {
      * @returns an `EmittedReference` which refers to the `Reference`, or `null` if none can be
      *   generated
      */
-    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): ReferenceEmitResult | null;
 }
 /**
  * Generates `Expression`s which refer to `Reference`s in a given context.
@@ -102,7 +134,7 @@ export interface ReferenceEmitStrategy {
 export declare class ReferenceEmitter {
     private strategies;
     constructor(strategies: ReferenceEmitStrategy[]);
-    emit(ref: Reference, context: ts.SourceFile, importFlags?: ImportFlags): EmittedReference;
+    emit(ref: Reference, context: ts.SourceFile, importFlags?: ImportFlags): ReferenceEmitResult;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if
@@ -118,11 +150,11 @@ interface ModuleExports {
     /**
      * The source file of the module.
      */
-    module: ts.SourceFile;
+    module: ts.SourceFile | null;
     /**
      * The map of declarations to their exported name.
      */
-    exportMap: Map<DeclarationNode, string>;
+    exportMap: Map<DeclarationNode, string> | null;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using
@@ -144,9 +176,9 @@ export declare class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
      */
     private moduleExportsCache;
     constructor(program: ts.Program, checker: ts.TypeChecker, moduleResolver: ModuleResolver, reflectionHost: ReflectionHost);
-    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): ReferenceEmitResult | null;
     private getExportsOfModule;
-    protected enumerateExportsOfModule(specifier: string, fromFile: string): ModuleExports | null;
+    protected enumerateExportsOfModule(specifier: string, fromFile: string): ModuleExports;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're
@@ -160,7 +192,7 @@ export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
     private reflector;
     private logicalFs;
     constructor(reflector: ReflectionHost, logicalFs: LogicalFileSystem);
-    emit(ref: Reference, context: ts.SourceFile): EmittedReference | null;
+    emit(ref: Reference, context: ts.SourceFile): ReferenceEmitResult | null;
 }
 /**
  * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.
@@ -171,7 +203,7 @@ export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
 export declare class RelativePathStrategy implements ReferenceEmitStrategy {
     private reflector;
     constructor(reflector: ReflectionHost);
-    emit(ref: Reference, context: ts.SourceFile): EmittedReference | null;
+    emit(ref: Reference, context: ts.SourceFile): ReferenceEmitResult | null;
 }
 /**
  * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import

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

@@ -28,10 +28,7 @@ export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implem
     visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
     visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;
     visitReturnStmt(stmt: o.ReturnStatement, context: Context): TStatement;
-    visitDeclareClassStmt(_stmt: o.ClassStmt, _context: Context): never;
     visitIfStmt(stmt: o.IfStmt, context: Context): TStatement;
-    visitTryCatchStmt(_stmt: o.TryCatchStmt, _context: Context): never;
-    visitThrowStmt(stmt: o.ThrowStmt, context: Context): TStatement;
     visitReadVarExpr(ast: o.ReadVarExpr, _context: Context): TExpression;
     visitWriteVarExpr(expr: o.WriteVarExpr, context: Context): TExpression;
     visitWriteKeyExpr(expr: o.WriteKeyExpr, context: Context): TExpression;
@@ -50,8 +47,6 @@ export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implem
     visitExternalExpr(ast: o.ExternalExpr, _context: Context): TExpression;
     visitConditionalExpr(ast: o.ConditionalExpr, context: Context): TExpression;
     visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
-    visitAssertNotNullExpr(ast: o.AssertNotNull, context: Context): TExpression;
-    visitCastExpr(ast: o.CastExpr, context: Context): TExpression;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): TExpression;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): TExpression;
     visitReadPropExpr(ast: o.ReadPropExpr, context: Context): TExpression;

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

@@ -30,8 +30,6 @@ export declare class TypeTranslatorVisitor implements o.ExpressionVisitor, o.Typ
     visitExternalExpr(ast: o.ExternalExpr, context: Context): ts.EntityName | ts.TypeReferenceNode;
     visitConditionalExpr(ast: o.ConditionalExpr, context: Context): void;
     visitNotExpr(ast: o.NotExpr, context: Context): void;
-    visitAssertNotNullExpr(ast: o.AssertNotNull, context: Context): void;
-    visitCastExpr(ast: o.CastExpr, context: Context): void;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): void;
     visitUnaryOperatorExpr(ast: o.UnaryOperatorExpr, context: Context): void;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): void;

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

@@ -6,24 +6,25 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/api/api" />
-import { AST, TmplAstNode } from '@angular/compiler';
+import { AST, ParseSourceSpan, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
-import { ErrorCode } from '../../../diagnostics';
+import { NgCompilerOptions } from '../../../core/api';
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../diagnostics';
 import { NgTemplateDiagnostic, TemplateTypeChecker } from '../../api';
 /**
  * A Template Check receives information about the template it's checking and returns
  * information about the diagnostics to be generated.
  */
-export interface TemplateCheck<T extends ErrorCode> {
+export interface TemplateCheck<Code extends ErrorCode> {
     /** Unique template check code, used for configuration and searching the error. */
-    code: T;
+    code: Code;
     /** Runs check and returns information about the diagnostics to be generated. */
-    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    run(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<Code>[];
 }
 /**
  * The TemplateContext provided to a Template Check to get diagnostic information.
  */
-export interface TemplateContext {
+export interface TemplateContext<Code extends ErrorCode> {
     /** Interface that provides information about template nodes. */
     templateTypeChecker: TemplateTypeChecker;
     /**
@@ -31,20 +32,39 @@ export interface TemplateContext {
      * in the template (it is not to query types outside the Angular component).
      */
     typeChecker: ts.TypeChecker;
+    /**
+     * Creates a template diagnostic with the given information for the template being processed and
+     * using the diagnostic category configured for the extended template diagnostic.
+     */
+    makeTemplateDiagnostic(sourceSpan: ParseSourceSpan, message: string, relatedInformation?: {
+        text: string;
+        start: number;
+        end: number;
+        sourceFile: ts.SourceFile;
+    }[]): NgTemplateDiagnostic<Code>;
+}
+/**
+ * A factory which creates a template check for a particular code and name. This binds the two
+ * together and associates them with a specific `TemplateCheck`.
+ */
+export interface TemplateCheckFactory<Code extends ErrorCode, Name extends ExtendedTemplateDiagnosticName> {
+    code: Code;
+    name: Name;
+    create(options: NgCompilerOptions): TemplateCheck<Code> | null;
 }
 /**
  * This abstract class provides a base implementation for the run method.
  */
-export declare abstract class TemplateCheckWithVisitor<T extends ErrorCode> implements TemplateCheck<T> {
-    abstract code: T;
+export declare abstract class TemplateCheckWithVisitor<Code extends ErrorCode> implements TemplateCheck<Code> {
+    abstract code: Code;
     /**
      * Base implementation for run function, visits all nodes in template and calls
      * `visitNode()` for each one.
      */
-    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    run(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<Code>[];
     /**
      * Visit a TmplAstNode or AST node of the template. Authors should override this
      * method to implement the check and return diagnostics.
      */
-    abstract visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<T>[];
+    abstract visitNode(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<Code>[];
 }

package/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box/index.d.ts

@@ -6,17 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box" />
-import { AST, TmplAstNode } from '@angular/compiler';
-import ts from 'typescript';
-import { ErrorCode } from '../../../../diagnostics';
-import { NgTemplateDiagnostic } from '../../../api';
-import { TemplateCheckWithVisitor, TemplateContext } from '../../api';
-/**
- * Ensures the two-way binding syntax is correct.
- * Parentheses should be inside the brackets "[()]".
- * Will return diagnostic information when "([])" is found.
- */
-export declare class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor<ErrorCode.INVALID_BANANA_IN_BOX> {
-    code: ErrorCode.INVALID_BANANA_IN_BOX;
-    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.INVALID_BANANA_IN_BOX>[];
-}
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.INVALID_BANANA_IN_BOX, ExtendedTemplateDiagnosticName.INVALID_BANANA_IN_BOX>;

package/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.d.ts

@@ -6,18 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable" />
-import { AST, TmplAstNode } from '@angular/compiler';
-import ts from 'typescript';
-import { ErrorCode } from '../../../../diagnostics';
-import { NgTemplateDiagnostic } from '../../../api';
-import { TemplateCheckWithVisitor, TemplateContext } from '../../api';
-/**
- * Ensures the left side of a nullish coalescing operation is nullable.
- * Returns diagnostics for the cases where the operator is useless.
- * This check should only be use if `strictNullChecks` is enabled,
- * otherwise it would produce inaccurate results.
- */
-export declare class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE> {
-    code: ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
-    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE>[];
-}
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE, ExtendedTemplateDiagnosticName.NULLISH_COALESCING_NOT_NULLABLE>;

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

@@ -6,4 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended" />
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../diagnostics';
+import { TemplateCheckFactory } from './api';
 export { ExtendedTemplateCheckerImpl } from './src/extended_template_checker';
+export declare const ALL_DIAGNOSTIC_FACTORIES: readonly TemplateCheckFactory<ErrorCode, ExtendedTemplateDiagnosticName>[];

package/src/ngtsc/typecheck/extended/src/extended_template_checker.d.ts

@@ -7,12 +7,13 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker" />
 import ts from 'typescript';
-import { ErrorCode } from '../../../diagnostics';
+import { NgCompilerOptions } from '../../../core/api';
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../diagnostics';
 import { TemplateDiagnostic, TemplateTypeChecker } from '../../api';
-import { ExtendedTemplateChecker, TemplateCheck } from '../api';
+import { ExtendedTemplateChecker, TemplateCheckFactory } from '../api';
 export declare class ExtendedTemplateCheckerImpl implements ExtendedTemplateChecker {
+    private readonly partialCtx;
     private readonly templateChecks;
-    private ctx;
-    constructor(templateTypeChecker: TemplateTypeChecker, typeChecker: ts.TypeChecker, templateChecks: TemplateCheck<ErrorCode>[]);
+    constructor(templateTypeChecker: TemplateTypeChecker, typeChecker: ts.TypeChecker, templateCheckFactories: readonly TemplateCheckFactory<ErrorCode, ExtendedTemplateDiagnosticName>[], options: NgCompilerOptions);
     getDiagnosticsForComponent(component: ts.ClassDeclaration): TemplateDiagnostic[];
 }

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

@@ -12,6 +12,7 @@ import { Reference, ReferenceEmitter } from '../../imports';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
 import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { ReferenceEmitEnvironment } from './tcb_util';
 /**
  * A context which hosts one or more Type Check Blocks (TCBs).
  *
@@ -23,7 +24,7 @@ import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
  * `Environment` can be used in a standalone fashion, or can be extended to support more specialized
  * usage.
  */
-export declare class Environment {
+export declare class Environment implements ReferenceEmitEnvironment {
     readonly config: TypeCheckingConfig;
     protected importManager: ImportManager;
     private refEmitter;
@@ -49,6 +50,7 @@ export declare class Environment {
      * This may involve importing the node into the file if it's not declared there already.
      */
     reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression;
+    canReferenceType(ref: Reference): boolean;
     /**
      * Generate a `ts.TypeNode` that references the given node as a type.
      *

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

@@ -11,6 +11,14 @@ import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../../../src/ngtsc/reflection';
 import { Reference } from '../../imports';
 import { FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping } from '../api';
+/**
+ * Represents the origin environment from where reference will be emitted. This interface exists
+ * as an indirection for the `Environment` type, which would otherwise introduce a (type-only)
+ * import cycle.
+ */
+export interface ReferenceEmitEnvironment {
+    canReferenceType(ref: Reference): boolean;
+}
 /**
  * Adapter interface which allows the template type-checking diagnostics code to interpret offsets
  * in a TCB and map them back to original locations in the template.
@@ -50,7 +58,7 @@ export declare enum TcbInliningRequirement {
      */
     None = 2
 }
-export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, reflector: ReflectionHost): TcbInliningRequirement;
+export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, env: ReferenceEmitEnvironment, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, reflector: ReflectionHost): TcbInliningRequirement;
 /** Maps a shim position back to a template location. */
 export declare function getTemplateMapping(shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver, isDiagnosticRequest: boolean): FullTemplateMapping | null;
 export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node | null;
@@ -61,4 +69,4 @@ export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId,
  * returns null.
  */
 export declare function findSourceLocation(node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticsRequest: boolean): SourceLocation | null;
-export declare function checkIfGenericTypeBoundsAreContextFree(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost): boolean;
+export declare function checkIfGenericTypeBoundsCanBeEmitted(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost, env: ReferenceEmitEnvironment): boolean;

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';
-export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined, reflector: ReflectionHost): ts.Statement;
+import { ReferenceEmitEnvironment } from './tcb_util';
+export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined): ts.Statement;
 /**
  * Generate an inline type constructor for the given class and metadata.
  *
@@ -46,4 +47,4 @@ export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.
  * @returns a `ts.MethodDeclaration` for the type constructor.
  */
 export declare function generateInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): ts.MethodDeclaration;
-export declare function requiresInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost): boolean;
+export declare function requiresInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost, env: ReferenceEmitEnvironment): boolean;

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

@@ -7,18 +7,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { Reference } from '../../imports';
 /**
- * A resolved type reference can either be a `Reference`, the original `ts.TypeReferenceNode` itself
- * or null. A value of null indicates that no reference could be resolved or that the reference can
- * not be emitted.
+ * A type reference resolver function is responsible for translating a type reference from the
+ * origin source file into a type reference that is valid in the desired source file. If the type
+ * cannot be translated to the desired source file, then null can be returned.
  */
-export declare type ResolvedTypeReference = Reference | ts.TypeReferenceNode | null;
-/**
- * A type reference resolver function is responsible for finding the declaration of the type
- * reference and verifying whether it can be emitted.
- */
-export declare type TypeReferenceResolver = (type: ts.TypeReferenceNode) => ResolvedTypeReference;
+export declare type TypeReferenceTranslator = (type: ts.TypeReferenceNode) => ts.TypeReferenceNode | null;
 /**
  * Determines whether the provided type can be emitted, which means that it can be safely emitted
  * into a different location.
@@ -27,7 +21,7 @@ export declare type TypeReferenceResolver = (type: ts.TypeReferenceNode) => Reso
  * function returns false, then using the `TypeEmitter` should not be attempted as it is known to
  * fail.
  */
-export declare function canEmitType(type: ts.TypeNode, resolver: TypeReferenceResolver): boolean;
+export declare function canEmitType(type: ts.TypeNode, canEmit: (type: ts.TypeReferenceNode) => boolean): boolean;
 /**
  * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into
  * a different context.
@@ -58,16 +52,8 @@ export declare function canEmitType(type: ts.TypeNode, resolver: TypeReferenceRe
  * referring to the namespace import that was created.
  */
 export declare class TypeEmitter {
-    /**
-     * Resolver function that computes a `Reference` corresponding with a `ts.TypeReferenceNode`.
-     */
-    private resolver;
-    /**
-     * Given a `Reference`, this function is responsible for the actual emitting work. It should
-     * produce a `ts.TypeNode` that is valid within the desired context.
-     */
-    private emitReference;
-    constructor(resolver: TypeReferenceResolver, emitReference: (ref: Reference) => ts.TypeNode);
+    private translator;
+    constructor(translator: TypeReferenceTranslator);
     emitType(type: ts.TypeNode): ts.TypeNode;
     private emitTypeReference;
 }

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

@@ -21,13 +21,13 @@ export declare class TypeParameterEmitter {
      * `emit` is known to succeed. Vice versa, if false is returned then `emit` should not be
      * called, as it would fail.
      */
-    canEmit(): boolean;
+    canEmit(canEmitReference: (ref: Reference) => boolean): boolean;
     private canEmitType;
     /**
      * Emits the type parameters using the provided emitter function for `Reference`s.
      */
     emit(emitReference: (ref: Reference) => ts.TypeNode): ts.TypeParameterDeclaration[] | undefined;
     private resolveTypeReference;
-    private isTopLevelExport;
+    private translateTypeReference;
     private isLocalTypeParameter;
 }