@angular/compiler-cli 15.0.0-next.4 → 15.0.0-next.6

package/ngcc/src/analysis/decoration_analyzer.d.ts

@@ -2,11 +2,12 @@
 import ts from 'typescript';
 import { ParsedConfiguration } from '../../..';
 import { ReferencesRegistry, ResourceLoader } from '../../../src/ngtsc/annotations';
+import { InjectableClassRegistry } from '../../../src/ngtsc/annotations/common';
 import { CycleAnalyzer, ImportGraph } from '../../../src/ngtsc/cycles';
 import { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
 import { ModuleResolver, PrivateExportAliasingHost, ReferenceEmitter } from '../../../src/ngtsc/imports';
 import { SemanticSymbol } from '../../../src/ngtsc/incremental/semantic_graph';
-import { CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, HostDirectivesResolver, InjectableClassRegistry, LocalMetadataRegistry } from '../../../src/ngtsc/metadata';
+import { CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, HostDirectivesResolver, LocalMetadataRegistry } from '../../../src/ngtsc/metadata';
 import { PartialEvaluator } from '../../../src/ngtsc/partial_evaluator';
 import { LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver, TypeCheckScopeRegistry } from '../../../src/ngtsc/scope';
 import { DecoratorHandler } from '../../../src/ngtsc/transform';

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 = "15.0.0-next.4";
+export declare const NGCC_VERSION = "15.0.0-next.6";
 /**
  * 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": "15.0.0-next.4",
+  "version": "15.0.0-next.6",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -65,8 +65,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "15.0.0-next.4",
-    "typescript": ">=4.6.2 <4.9"
+    "@angular/compiler": "15.0.0-next.6",
+    "typescript": ">=4.8.2 <4.9"
   },
   "repository": {
     "type": "git",
@@ -79,7 +79,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": "^14.15.0 || >=16.10.0"
+    "node": "^14.20.0 || ^16.13.0 || >=18.10.0"
   },
   "bugs": {
     "url": "https://github.com/angular/angular/issues"

package/src/ngtsc/annotations/common/index.d.ts

@@ -11,6 +11,7 @@ export * from './src/di';
 export * from './src/diagnostics';
 export * from './src/evaluation';
 export * from './src/factory';
+export * from './src/injectable_registry';
 export * from './src/metadata';
 export * from './src/references_registry';
 export * from './src/schema';

package/src/ngtsc/annotations/common/src/diagnostics.d.ts

@@ -9,10 +9,11 @@
 import ts from 'typescript';
 import { FatalDiagnosticError } from '../../../diagnostics';
 import { Reference } from '../../../imports';
-import { HostDirectiveMeta, InjectableClassRegistry, MetadataReader } from '../../../metadata';
+import { HostDirectiveMeta, MetadataReader } from '../../../metadata';
 import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
 import { ClassDeclaration, ReflectionHost } from '../../../reflection';
 import { DeclarationData, LocalModuleScopeRegistry } from '../../../scope';
+import { InjectableClassRegistry } from './injectable_registry';
 /**
  * Create a `ts.Diagnostic` which indicates the given class is part of the declarations of two or
  * more NgModules.
@@ -39,7 +40,14 @@ export declare function createValueHasWrongTypeError(node: ts.Node, value: Resol
  * @param registry Registry that keeps track of the registered injectable classes.
  */
 export declare function getProviderDiagnostics(providerClasses: Set<Reference<ClassDeclaration>>, providersDeclaration: ts.Expression, registry: InjectableClassRegistry): ts.Diagnostic[];
-export declare function getDirectiveDiagnostics(node: ClassDeclaration, reader: MetadataReader, evaluator: PartialEvaluator, reflector: ReflectionHost, scopeRegistry: LocalModuleScopeRegistry, kind: string): ts.Diagnostic[] | null;
+export declare function getDirectiveDiagnostics(node: ClassDeclaration, injectableRegistry: InjectableClassRegistry, evaluator: PartialEvaluator, reflector: ReflectionHost, scopeRegistry: LocalModuleScopeRegistry, strictInjectionParameters: boolean, kind: 'Directive' | 'Component'): ts.Diagnostic[] | null;
 export declare function validateHostDirectives(origin: ts.Expression, hostDirectives: HostDirectiveMeta[], metaReader: MetadataReader): ts.DiagnosticWithLocation[];
 export declare function getUndecoratedClassWithAngularFeaturesDiagnostic(node: ClassDeclaration): ts.Diagnostic;
-export declare function checkInheritanceOfDirective(node: ClassDeclaration, reader: MetadataReader, reflector: ReflectionHost, evaluator: PartialEvaluator): ts.Diagnostic | null;
+export declare function checkInheritanceOfInjectable(node: ClassDeclaration, injectableRegistry: InjectableClassRegistry, reflector: ReflectionHost, evaluator: PartialEvaluator, strictInjectionParameters: boolean, kind: 'Directive' | 'Component' | 'Pipe' | 'Injectable'): ts.Diagnostic | null;
+interface ClassWithCtor {
+    ref: Reference<ClassDeclaration>;
+    isCtorValid: boolean;
+    isDecorated: boolean;
+}
+export declare function findInheritedCtor(node: ClassDeclaration, injectableRegistry: InjectableClassRegistry, reflector: ReflectionHost, evaluator: PartialEvaluator): ClassWithCtor | null;
+export {};

package/src/ngtsc/annotations/common/src/injectable_registry.d.ts

@@ -0,0 +1,25 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/common/src/injectable_registry" />
+/**
+ * @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
+ */
+import { R3DependencyMetadata } from '@angular/compiler';
+import { ClassDeclaration, ReflectionHost } from '../../../reflection';
+export interface InjectableMeta {
+    ctorDeps: R3DependencyMetadata[] | 'invalid' | null;
+}
+/**
+ * Registry that keeps track of classes that can be constructed via dependency injection (e.g.
+ * injectables, directives, pipes).
+ */
+export declare class InjectableClassRegistry {
+    private host;
+    private isCore;
+    private classes;
+    constructor(host: ReflectionHost, isCore: boolean);
+    registerInjectable(declaration: ClassDeclaration, meta: InjectableMeta): void;
+    getInjectableMeta(declaration: ClassDeclaration): InjectableMeta | null;
+}

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

@@ -100,3 +100,4 @@ export declare function resolveImportedFile(moduleResolver: ModuleResolver, impo
  * used.
  */
 export declare function getOriginNodeForDiagnostics(expr: ts.Expression, container: ts.Expression): ts.Expression;
+export declare function isAbstractClassDeclaration(clazz: ClassDeclaration): boolean;

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

@@ -13,7 +13,7 @@ import { ModuleResolver, ReferenceEmitter } from '../../../imports';
 import { DependencyTracker } from '../../../incremental/api';
 import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
 import { IndexingContext } from '../../../indexer';
-import { HostDirectivesResolver, InjectableClassRegistry, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
+import { HostDirectivesResolver, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
@@ -22,7 +22,7 @@ import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerF
 import { TypeCheckContext } from '../../../typecheck/api';
 import { ExtendedTemplateChecker } from '../../../typecheck/extended/api';
 import { Xi18nContext } from '../../../xi18n';
-import { ResourceLoader } from '../../common';
+import { InjectableClassRegistry, ResourceLoader } from '../../common';
 import { ComponentAnalysisData, ComponentResolutionData } from './metadata';
 import { ComponentSymbol } from './symbol';
 /**
@@ -39,6 +39,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private typeCheckScopeRegistry;
     private resourceRegistry;
     private isCore;
+    private strictCtorDeps;
     private resourceLoader;
     private rootDirs;
     private defaultPreserveWhitespaces;
@@ -56,7 +57,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private annotateForClosureCompiler;
     private perf;
     private hostDirectivesResolver;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver);
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, dtsScopeReader: DtsModuleScopeResolver, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver);
     private literalCache;
     private elementSchemaRegistry;
     /**

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

@@ -10,12 +10,13 @@ import { ConstantPool, R3ClassMetadata, R3DirectiveMetadata } from '@angular/com
 import ts from 'typescript';
 import { Reference, ReferenceEmitter } from '../../../imports';
 import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
-import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, MetadataReader, MetadataRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { LocalModuleScopeRegistry } from '../../../scope';
 import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence, ResolveResult } from '../../../transform';
+import { InjectableClassRegistry } from '../../common';
 import { DirectiveSymbol } from './symbol';
 export interface DirectiveHandlerData {
     baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
@@ -40,11 +41,12 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     private injectableRegistry;
     private refEmitter;
     private isCore;
+    private strictCtorDeps;
     private semanticDepGraphUpdater;
     private annotateForClosureCompiler;
     private compileUndecoratedClassesWithAngularFeatures;
     private perf;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, isCore: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, compileUndecoratedClassesWithAngularFeatures: boolean, perf: PerfRecorder);
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, compileUndecoratedClassesWithAngularFeatures: boolean, perf: PerfRecorder);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name: string;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;

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

@@ -10,14 +10,14 @@ import { Expression, R3ClassMetadata, R3FactoryMetadata, R3InjectorMetadata, R3N
 import ts from 'typescript';
 import { Reference, ReferenceEmitter } from '../../../imports';
 import { SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
-import { InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { MetadataReader, MetadataRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { LocalModuleScopeRegistry } from '../../../scope';
 import { FactoryTracker } from '../../../shims/api';
 import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../../transform';
-import { ReferencesRegistry } from '../../common';
+import { InjectableClassRegistry, ReferencesRegistry } from '../../common';
 export interface NgModuleAnalysis {
     mod: R3NgModuleMetadata;
     inj: Omit<R3InjectorMetadata, 'imports'>;

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

@@ -7,10 +7,11 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/injectable" />
 import { R3ClassMetadata, R3DependencyMetadata, R3InjectableMetadata } from '@angular/compiler';
-import { InjectableClassRegistry } from '../../metadata';
+import { InjectableClassRegistry } from '../../annotations/common';
+import { PartialEvaluator } from '../../partial_evaluator';
 import { PerfRecorder } from '../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
-import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence } from '../../transform';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../transform';
 export interface InjectableHandlerData {
     meta: R3InjectableMetadata;
     classMetadata: R3ClassMetadata | null;
@@ -22,6 +23,7 @@ export interface InjectableHandlerData {
  */
 export declare class InjectableDecoratorHandler implements DecoratorHandler<Decorator, InjectableHandlerData, null, unknown> {
     private reflector;
+    private evaluator;
     private isCore;
     private strictCtorDeps;
     private injectableRegistry;
@@ -33,7 +35,7 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
      * If false then there is no error and a new ɵprov property is not added.
      */
     private errorOnDuplicateProv;
-    constructor(reflector: ReflectionHost, isCore: boolean, strictCtorDeps: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder, 
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, isCore: boolean, strictCtorDeps: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder, 
     /**
      * What to do if the injectable already contains a ɵprov property.
      *
@@ -46,7 +48,8 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator>): AnalysisOutput<InjectableHandlerData>;
     symbol(): null;
-    register(node: ClassDeclaration): void;
+    register(node: ClassDeclaration, analysis: InjectableHandlerData): void;
+    resolve(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>, symbol: null): ResolveResult<unknown>;
     compileFull(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
     compilePartial(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
     private compile;

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

@@ -9,12 +9,13 @@
 import { R3ClassMetadata, R3PipeMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { SemanticSymbol } from '../../incremental/semantic_graph';
-import { InjectableClassRegistry, MetadataRegistry } from '../../metadata';
+import { MetadataRegistry } from '../../metadata';
 import { PartialEvaluator } from '../../partial_evaluator';
 import { PerfRecorder } from '../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
 import { LocalModuleScopeRegistry } from '../../scope';
 import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../transform';
+import { InjectableClassRegistry } from '../common';
 export interface PipeHandlerData {
     meta: R3PipeMetadata;
     classMetadata: R3ClassMetadata | null;

package/src/ngtsc/core/src/host.d.ts

@@ -49,6 +49,7 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     useCaseSensitiveFileNames: () => boolean;
     writeFile: ts.WriteFileCallback;
     getModuleResolutionCache: (() => ts.ModuleResolutionCache | undefined) | undefined;
+    hasInvalidatedResolutions: (() => string) | ((fileName: string) => string) | ((fileName: string) => boolean) | ((fileName: string) => string | undefined) | ((s: string) => void) | ((directoryName: string) => boolean) | ((path: string) => string) | ((path: string) => string[]) | ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | (() => boolean) | (() => Set<string> | undefined) | ((fileName: string) => string | Promise<string>) | ((resourceName: string, containingFilePath: string, fallbackResolve?: ((url: string, fromFile: string) => string | null) | undefined) => string | null) | ((data: string, context: import("@angular/compiler-cli/src/ngtsc/core/api/index").ResourceHostContext) => Promise<import("@angular/compiler-cli/src/ngtsc/core/api/index").TransformResourceResult | null>) | ((importedFilePath: string, containingFilePath: string) => string) | ((fileName: string, path: ts.Path, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | (() => ts.CancellationToken) | ((options: ts.CompilerOptions) => string) | (() => string) | ts.WriteFileCallback | (() => string) | ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | (() => ts.ModuleResolutionCache | undefined) | ((typeReferenceDirectiveNames: string[] | readonly ts.FileReference[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingFileMode?: ts.ModuleKind.CommonJS | ts.ModuleKind.ESNext | undefined) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | ((name: string) => string | undefined) | ((data: string) => string) | ((fileName: string) => ts.ParsedCommandLine | undefined) | ((fileName: string, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
 }
 /**
  * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).

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

@@ -71,6 +71,11 @@ export declare enum ErrorCode {
      * Raised when a host directive is a component.
      */
     HOST_DIRECTIVE_COMPONENT = 2015,
+    /**
+     * Raised when a type with Angular decorator inherits its constructor from a base class
+     * which has a constructor that is incompatible with Angular DI.
+     */
+    INJECTABLE_INHERITS_INVALID_CONSTRUCTOR = 2016,
     SYMBOL_NOT_EXPORTED = 3001,
     /**
      * Raised when a relationship between directives and/or pipes would cause a cyclic import to be

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

@@ -9,8 +9,8 @@
 export * from './src/api';
 export { DtsMetadataReader } from './src/dts';
 export { flattenInheritedDirectiveMetadata } from './src/inheritance';
-export { CompoundMetadataRegistry, LocalMetadataRegistry, InjectableClassRegistry } from './src/registry';
+export { CompoundMetadataRegistry, LocalMetadataRegistry } from './src/registry';
 export { ResourceRegistry, Resource, ComponentResources, isExternalResource, ExternalResource } from './src/resource_registry';
-export { extractDirectiveTypeCheckMeta, CompoundMetadataReader } from './src/util';
+export { extractDirectiveTypeCheckMeta, hasInjectableFields, CompoundMetadataReader } from './src/util';
 export { BindingPropertyName, ClassPropertyMapping, ClassPropertyName, InputOrOutput } from './src/property_mapping';
 export { HostDirectivesResolver } from './src/host_directives_resolver';

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

@@ -215,6 +215,12 @@ export interface MetadataReader {
     getNgModuleMetadata(node: Reference<ClassDeclaration>): NgModuleMeta | null;
     getPipeMetadata(node: Reference<ClassDeclaration>): PipeMeta | null;
 }
+/**
+ * A MetadataReader which also allows access to the set of all known directive classes.
+ */
+export interface MetadataReaderWithIndex extends MetadataReader {
+    getKnownDirectives(): Iterable<ClassDeclaration>;
+}
 /**
  * Registers new metadata for directives, pipes, and modules.
  */

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

@@ -7,13 +7,13 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/metadata/src/registry" />
 import { Reference } from '../../imports';
-import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { DirectiveMeta, MetadataReader, MetadataRegistry, NgModuleMeta, PipeMeta } from './api';
+import { ClassDeclaration } from '../../reflection';
+import { DirectiveMeta, MetadataReaderWithIndex, MetadataRegistry, NgModuleMeta, PipeMeta } from './api';
 /**
  * A registry of directive, pipe, and module metadata for types defined in the current compilation
  * unit, which supports both reading and registering.
  */
-export declare class LocalMetadataRegistry implements MetadataRegistry, MetadataReader {
+export declare class LocalMetadataRegistry implements MetadataRegistry, MetadataReaderWithIndex {
     private directives;
     private ngModules;
     private pipes;
@@ -23,6 +23,7 @@ export declare class LocalMetadataRegistry implements MetadataRegistry, Metadata
     registerDirectiveMetadata(meta: DirectiveMeta): void;
     registerNgModuleMetadata(meta: NgModuleMeta): void;
     registerPipeMetadata(meta: PipeMeta): void;
+    getKnownDirectives(): Iterable<ClassDeclaration>;
 }
 /**
  * A `MetadataRegistry` which registers metadata with multiple delegate `MetadataRegistry`
@@ -35,14 +36,3 @@ export declare class CompoundMetadataRegistry implements MetadataRegistry {
     registerNgModuleMetadata(meta: NgModuleMeta): void;
     registerPipeMetadata(meta: PipeMeta): void;
 }
-/**
- * Registry that keeps track of classes that can be constructed via dependency injection (e.g.
- * injectables, directives, pipes).
- */
-export declare class InjectableClassRegistry {
-    private host;
-    private classes;
-    constructor(host: ReflectionHost);
-    registerInjectable(declaration: ClassDeclaration): void;
-    isInjectable(declaration: ClassDeclaration): boolean;
-}

package/src/ngtsc/program_driver/src/ts_create_program_driver.d.ts

@@ -41,6 +41,7 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
     getModuleResolutionCache: (() => ts.ModuleResolutionCache | undefined) | undefined;
+    hasInvalidatedResolutions: ((fileName: string, path: ts.Path, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | (() => ts.CancellationToken) | ((options: ts.CompilerOptions) => string) | (() => string) | (() => string) | ((fileName: string) => string) | (() => boolean) | (() => string) | ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | (() => ts.ModuleResolutionCache | undefined) | ((typeReferenceDirectiveNames: string[] | readonly ts.FileReference[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingFileMode?: ts.ModuleKind.CommonJS | ts.ModuleKind.ESNext | undefined) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | ((name: string) => string | undefined) | ((data: string) => string) | ((fileName: string) => ts.ParsedCommandLine | undefined) | ((fileName: string) => string | undefined) | ((s: string) => void) | ((directoryName: string) => boolean) | ((path: string) => string) | ((path: string) => string[]) | ((fileName: string, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | ((fileName: string) => boolean) | ts.WriteFileCallback | undefined;
 }
 /**
  * Updates a `ts.Program` instance with a new one that incorporates specific changes, using the

package/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.d.ts

@@ -9,15 +9,6 @@
 import ts from 'typescript';
 /** Equivalent of `ts.ModifierLike` which is only present in TS 4.8+. */
 export declare type ModifierLike = ts.Modifier | ts.Decorator;
-/** Type of `ts.factory.updateTypeParameterDeclaration` in TS 4.7+. */
-declare type Ts47UpdateTypeParameterDeclarationFn = (node: ts.TypeParameterDeclaration, modifiers: readonly ts.Modifier[] | undefined, name: ts.Identifier, constraint: ts.TypeNode | undefined, defaultType: ts.TypeNode | undefined) => ts.TypeParameterDeclaration;
-/**
- * Updates a `ts.TypeParameter` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.7.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updateTypeParameterDeclaration: Ts47UpdateTypeParameterDeclarationFn;
 /** Type of `ts.factory.updateParameterDeclaration` in TS 4.8+. */
 declare type Ts48UpdateParameterDeclarationFn = (node: ts.ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: ts.DotDotDotToken | undefined, name: string | ts.BindingName, questionToken: ts.QuestionToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.ParameterDeclaration;
 /**

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

@@ -12,7 +12,7 @@ import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
 import { ErrorCode } from '../../diagnostics';
 import { FullTemplateMapping, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
 import { GlobalCompletion } from './completion';
-import { DirectiveInScope, PipeInScope } from './scope';
+import { PotentialDirective, PotentialImport, PotentialPipe } from './scope';
 import { ElementSymbol, Symbol, TcbLocation, TemplateSymbol } from './symbols';
 /**
  * Interface to the Angular Template Type Checker to extract diagnostics and intelligence from the
@@ -109,19 +109,24 @@ export interface TemplateTypeChecker {
      */
     getLiteralCompletionLocation(strNode: LiteralPrimitive | TmplAstTextAttribute, component: ts.ClassDeclaration): TcbLocation | null;
     /**
-     * Get basic metadata on the directives which are in scope for the given component.
+     * Get basic metadata on the directives which are in scope or can be imported for the given
+     * component.
      */
-    getDirectivesInScope(component: ts.ClassDeclaration): DirectiveInScope[] | null;
+    getPotentialTemplateDirectives(component: ts.ClassDeclaration): PotentialDirective[];
     /**
      * Get basic metadata on the pipes which are in scope for the given component.
      */
-    getPipesInScope(component: ts.ClassDeclaration): PipeInScope[] | null;
+    getPipesInScope(component: ts.ClassDeclaration): PotentialPipe[] | null;
     /**
-     * Retrieve a `Map` of potential template element tags, to either the `DirectiveInScope` that
+     * Retrieve a `Map` of potential template element tags, to either the `PotentialDirective` that
      * declares them (if the tag is from a directive/component), or `null` if the tag originates from
      * the DOM schema.
      */
-    getPotentialElementTags(component: ts.ClassDeclaration): Map<string, DirectiveInScope | null>;
+    getPotentialElementTags(component: ts.ClassDeclaration): Map<string, PotentialDirective | null>;
+    /**
+     * In the context of an Angular trait, generate potential imports for a directive.
+     */
+    getPotentialImportsFor(directive: PotentialDirective, inComponent: ts.ClassDeclaration): ReadonlyArray<PotentialImport>;
     /**
      * Get the primary decorator for an Angular class (such as @Component). This does not work for
      * `@Injectable`.

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

@@ -7,12 +7,30 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/api/scope" />
 import ts from 'typescript';
+import { Reference } from '../../imports';
 import { ClassDeclaration } from '../../reflection';
 import { SymbolWithValueDeclaration } from '../../util/src/typescript';
 /**
- * Metadata on a directive which is available in the scope of a template.
+ * A PotentialImport for some Angular trait has a TypeScript module specifier, which can be
+ * relative, as well as an identifier name.
  */
-export interface DirectiveInScope {
+export interface PotentialImport {
+    kind: PotentialImportKind;
+    moduleSpecifier: string;
+    symbolName: string;
+}
+/**
+ * Which kind of Angular Trait the import targets.
+ */
+export declare enum PotentialImportKind {
+    NgModule = 0,
+    Standalone = 1
+}
+/**
+ * Metadata on a directive which is available in a template.
+ */
+export interface PotentialDirective {
+    ref: Reference<ClassDeclaration>;
     /**
      * The `ts.Symbol` for the directive class.
      */
@@ -33,11 +51,15 @@ export interface DirectiveInScope {
      * `true` if this directive is a structural directive.
      */
     isStructural: boolean;
+    /**
+     * Whether or not this directive is in scope.
+     */
+    isInScope: boolean;
 }
 /**
- * Metadata for a pipe which is available in the scope of a template.
+ * Metadata for a pipe which is available in a template.
  */
-export interface PipeInScope {
+export interface PotentialPipe {
     /**
      * The `ts.Symbol` for the pipe class.
      */
@@ -46,4 +68,8 @@ export interface PipeInScope {
      * Name of the pipe.
      */
     name: string;
+    /**
+     * Whether or not this pipe is in scope.
+     */
+    isInScope: boolean;
 }

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

@@ -10,7 +10,7 @@ import { TmplAstElement, TmplAstReference, TmplAstTemplate, TmplAstVariable } fr
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { SymbolWithValueDeclaration } from '../../util/src/typescript';
-import { DirectiveInScope } from './scope';
+import { PotentialDirective } from './scope';
 export declare enum SymbolKind {
     Input = 0,
     Output = 1,
@@ -214,7 +214,7 @@ export interface TemplateSymbol {
  * A representation of a directive/component whose selector matches a node in a component
  * template.
  */
-export interface DirectiveSymbol extends DirectiveInScope {
+export interface DirectiveSymbol extends PotentialDirective {
     kind: SymbolKind.Directive;
     /** The `ts.Type` for the class declaration. */
     tsType: ts.Type;

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

@@ -12,12 +12,12 @@ import { ErrorCode } from '../../diagnostics';
 import { AbsoluteFsPath } from '../../file_system';
 import { ReferenceEmitter } from '../../imports';
 import { IncrementalBuild } from '../../incremental/api';
-import { MetadataReader } from '../../metadata';
+import { MetadataReader, MetadataReaderWithIndex } from '../../metadata';
 import { PerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { ReflectionHost } from '../../reflection';
 import { ComponentScopeReader, TypeCheckScopeRegistry } from '../../scope';
-import { DirectiveInScope, ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PipeInScope, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PotentialDirective, PotentialImport, PotentialPipe, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
 import { ShimTypeCheckingData } from './context';
 import { TemplateSourceManager } from './source';
 /**
@@ -35,6 +35,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     private compilerHost;
     private priorBuild;
     private readonly metaReader;
+    private readonly localMetaReader;
     private readonly componentScopeReader;
     private readonly typeCheckScopeRegistry;
     private readonly perf;
@@ -73,7 +74,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
      */
     private elementTagCache;
     private isComplete;
-    constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
+    constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
     getTemplate(component: ts.ClassDeclaration): TmplAstNode[] | null;
     private getLatestComponentState;
     isTrackedTypeCheckFile(filePath: AbsoluteFsPath): boolean;
@@ -116,10 +117,10 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getSymbolOfNode(node: TmplAstTemplate, component: ts.ClassDeclaration): TemplateSymbol | null;
     getSymbolOfNode(node: TmplAstElement, component: ts.ClassDeclaration): ElementSymbol | null;
     private getOrCreateSymbolBuilder;
-    getDirectivesInScope(component: ts.ClassDeclaration): DirectiveInScope[] | null;
-    getPipesInScope(component: ts.ClassDeclaration): PipeInScope[] | null;
+    getPotentialTemplateDirectives(component: ts.ClassDeclaration): PotentialDirective[];
+    getPipesInScope(component: ts.ClassDeclaration): PotentialPipe[] | null;
     getDirectiveMetadata(dir: ts.ClassDeclaration): TypeCheckableDirectiveMeta | null;
-    getPotentialElementTags(component: ts.ClassDeclaration): Map<string, DirectiveInScope | null>;
+    getPotentialElementTags(component: ts.ClassDeclaration): Map<string, PotentialDirective | null>;
     getPotentialDomBindings(tagName: string): {
         attribute: string;
         property: string;
@@ -127,7 +128,9 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getPotentialDomEvents(tagName: string): string[];
     getPrimaryAngularDecorator(target: ts.ClassDeclaration): ts.Decorator | null;
     getOwningNgModule(component: ts.ClassDeclaration): ts.ClassDeclaration | null;
+    getPotentialImportsFor(toImport: PotentialDirective, inContext: ts.ClassDeclaration): ReadonlyArray<PotentialImport>;
     private getScopeData;
+    private scopeDataOfDirectiveMeta;
 }
 /**
  * Data for template type-checking related to a specific input file in the user's program (which