@angular/compiler-cli 14.2.0-next.1 → 15.0.0-next.0

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

@@ -6,7 +6,7 @@ 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, InjectableClassRegistry, LocalMetadataRegistry } from '../../../src/ngtsc/metadata';
+import { CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, HostDirectivesResolver, InjectableClassRegistry, 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';
@@ -60,6 +60,7 @@ export declare class DecorationAnalyzer {
     importGraph: ImportGraph;
     cycleAnalyzer: CycleAnalyzer;
     injectableRegistry: InjectableClassRegistry;
+    hostDirectivesResolver: HostDirectivesResolver;
     typeCheckScopeRegistry: TypeCheckScopeRegistry;
     handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[];
     compiler: NgccTraitCompiler;

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 = "14.2.0-next.1";
+export declare const NGCC_VERSION = "15.0.0-next.0";
 /**
  * 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": "14.2.0-next.1",
+  "version": "15.0.0-next.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -65,8 +65,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "14.2.0-next.1",
-    "typescript": ">=4.6.2 <4.8"
+    "@angular/compiler": "15.0.0-next.0",
+    "typescript": ">=4.6.2 <4.9"
   },
   "repository": {
     "type": "git",

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

@@ -9,7 +9,7 @@
 import ts from 'typescript';
 import { FatalDiagnosticError } from '../../../diagnostics';
 import { Reference } from '../../../imports';
-import { InjectableClassRegistry, MetadataReader } from '../../../metadata';
+import { HostDirectiveMeta, InjectableClassRegistry, MetadataReader } from '../../../metadata';
 import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
 import { ClassDeclaration, ReflectionHost } from '../../../reflection';
 import { DeclarationData, LocalModuleScopeRegistry } from '../../../scope';
@@ -40,5 +40,6 @@ export declare function createValueHasWrongTypeError(node: ts.Node, value: Resol
  */
 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 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;

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 { InjectableClassRegistry, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
+import { HostDirectivesResolver, InjectableClassRegistry, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
@@ -55,7 +55,8 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private semanticDepGraphUpdater;
     private annotateForClosureCompiler;
     private perf;
-    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);
+    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);
     private literalCache;
     private elementSchemaRegistry;
     /**

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

@@ -9,7 +9,7 @@
 import { AnimationTriggerNames, R3ClassMetadata, R3ComponentMetadata, R3TemplateDependencyMetadata, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../../imports';
-import { ClassPropertyMapping, ComponentResources, DirectiveTypeCheckMeta } from '../../../metadata';
+import { ClassPropertyMapping, ComponentResources, DirectiveTypeCheckMeta, HostDirectiveMeta } from '../../../metadata';
 import { ClassDeclaration } from '../../../reflection';
 import { SubsetOfKeys } from '../../../util/src/typescript';
 import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
@@ -56,5 +56,10 @@ export interface ComponentAnalysisData {
     rawImports: ts.Expression | null;
     resolvedImports: Reference<ClassDeclaration>[] | null;
     schemas: SchemaMetadata[] | null;
+    decorator: ts.Decorator | null;
+    /** Additional directives applied to the component host. */
+    hostDirectives: HostDirectiveMeta[] | null;
+    /** Raw expression that defined the host directives array. Used for diagnostics. */
+    rawHostDirectives: ts.Expression | null;
 }
 export declare type ComponentResolutionData = Pick<R3ComponentMetadata<R3TemplateDependencyMetadata>, ComponentMetadataResolvedFields>;

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

@@ -7,9 +7,10 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/directive/src/handler" />
 import { ConstantPool, R3ClassMetadata, R3DirectiveMetadata } from '@angular/compiler';
-import { Reference } from '../../../imports';
+import ts from 'typescript';
+import { Reference, ReferenceEmitter } from '../../../imports';
 import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
-import { ClassPropertyMapping, DirectiveTypeCheckMeta, InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
@@ -26,6 +27,9 @@ export interface DirectiveHandlerData {
     outputs: ClassPropertyMapping;
     isPoisoned: boolean;
     isStructural: boolean;
+    decorator: ts.Decorator | null;
+    hostDirectives: HostDirectiveMeta[] | null;
+    rawHostDirectives: ts.Expression | null;
 }
 export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decorator | null, DirectiveHandlerData, DirectiveSymbol, unknown> {
     private reflector;
@@ -34,12 +38,13 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     private scopeRegistry;
     private metaReader;
     private injectableRegistry;
+    private refEmitter;
     private isCore;
     private semanticDepGraphUpdater;
     private annotateForClosureCompiler;
     private compileUndecoratedClassesWithAngularFeatures;
     private perf;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, 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, 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/directive/src/shared.d.ts

@@ -8,7 +8,8 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/directive/src/shared" />
 import { ParsedHostBindings, R3DirectiveMetadata, R3QueryMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { ClassPropertyMapping } from '../../../metadata';
+import { ReferenceEmitter } from '../../../imports';
+import { ClassPropertyMapping, HostDirectiveMeta } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../../reflection';
 import { HandlerFlags } from '../../../transform';
@@ -18,12 +19,14 @@ import { HandlerFlags } from '../../../transform';
  * appear in the declarations of an `NgModule` and additional verification is done when processing
  * the module.
  */
-export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Readonly<Decorator | null>, reflector: ReflectionHost, evaluator: PartialEvaluator, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
+export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Readonly<Decorator | null>, reflector: ReflectionHost, evaluator: PartialEvaluator, refEmitter: ReferenceEmitter, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
     decorator: Map<string, ts.Expression>;
     metadata: R3DirectiveMetadata;
     inputs: ClassPropertyMapping;
     outputs: ClassPropertyMapping;
     isStructural: boolean;
+    hostDirectives: HostDirectiveMeta[] | null;
+    rawHostDirectives: ts.Expression | null;
 } | undefined;
 export declare function extractQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
 export declare function extractHostBindings(members: ClassMember[], evaluator: PartialEvaluator, coreModule: string | undefined, metadata?: Map<string, ts.Expression>): ParsedHostBindings;

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

@@ -36,6 +36,7 @@ export interface NgModuleAnalysis {
     providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
     providers: ts.Expression | null;
     remoteScopesMayRequireCycleProtection: boolean;
+    decorator: ts.Decorator | null;
 }
 export interface NgModuleResolution {
     injectorImports: Expression[];

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

@@ -19,6 +19,7 @@ export interface PipeHandlerData {
     meta: R3PipeMetadata;
     classMetadata: R3ClassMetadata | null;
     pipeNameExpr: ts.Expression;
+    decorator: ts.Decorator | null;
 }
 /**
  * Represents an Angular pipe.

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

@@ -12,6 +12,10 @@ import { BazelAndG3Options, DiagnosticOptions, I18nOptions, LegacyNgcOptions, Mi
  * Non-public options which are useful during testing of the compiler.
  */
 export interface TestOnlyOptions {
+    /**
+     * Enable the Language Service APIs for template type-checking for tests.
+     */
+    _enableTemplateTypeChecker?: boolean;
     /**
      * An option to enable ngtsc's internal performance tracing.
      *

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

@@ -100,7 +100,6 @@ export declare class NgCompiler {
     readonly programDriver: ProgramDriver;
     readonly incrementalStrategy: IncrementalBuildStrategy;
     readonly incrementalCompilation: IncrementalCompilation;
-    readonly enableTemplateTypeChecker: boolean;
     readonly usePoisonedData: boolean;
     private livePerfRecorder;
     /**
@@ -130,6 +129,7 @@ export declare class NgCompiler {
     private cycleAnalyzer;
     readonly ignoreForDiagnostics: Set<ts.SourceFile>;
     readonly ignoreForEmit: Set<ts.SourceFile>;
+    readonly enableTemplateTypeChecker: boolean;
     /**
      * `NgCompiler` can be reused for multiple compilations (for resource-only changes), and each
      * new compilation uses a fresh `PerfRecorder`. Thus, classes created with a lifespan of the

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

@@ -59,6 +59,18 @@ export declare enum ErrorCode {
      * Raised when a type in the `imports` of a component is not a directive, pipe, or NgModule.
      */
     COMPONENT_UNKNOWN_IMPORT = 2012,
+    /**
+     * Raised when the compiler wasn't able to resolve the metadata of a host directive.
+     */
+    HOST_DIRECTIVE_INVALID = 2013,
+    /**
+     * Raised when a host directive isn't standalone.
+     */
+    HOST_DIRECTIVE_NOT_STANDALONE = 2014,
+    /**
+     * Raised when a host directive is a component.
+     */
+    HOST_DIRECTIVE_COMPONENT = 2015,
     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

@@ -13,3 +13,4 @@ export { CompoundMetadataRegistry, LocalMetadataRegistry, InjectableClassRegistr
 export { ResourceRegistry, Resource, ComponentResources, isExternalResource, ExternalResource } from './src/resource_registry';
 export { extractDirectiveTypeCheckMeta, 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

@@ -42,6 +42,12 @@ export interface NgModuleMeta {
      * because the module came from a .d.ts file).
      */
     rawExports: ts.Expression | null;
+    /**
+     * The primary decorator associated with this `ngModule`.
+     *
+     * If this is `null`, no decorator exists, meaning it's probably from a .d.ts file.
+     */
+    decorator: ts.Decorator | null;
 }
 /**
  * Typing metadata collected for a directive within an NgModule's scope.
@@ -90,11 +96,22 @@ export declare enum MetaKind {
     Pipe = 1,
     NgModule = 2
 }
+/**
+ * Possible ways that a directive can be matched.
+ */
+export declare enum MatchSource {
+    /** The directive was matched by its selector. */
+    Selector = 0,
+    /** The directive was applied as a host directive. */
+    HostDirective = 1
+}
 /**
  * Metadata collected for a directive within an NgModule's scope.
  */
 export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
     kind: MetaKind.Directive;
+    /** Way in which the directive was matched. */
+    matchSource: MatchSource;
     ref: Reference<ClassDeclaration>;
     /**
      * Unparsed selector of the directive, or null if the directive does not have a selector.
@@ -137,6 +154,29 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * For standalone components, the list of schemas declared.
      */
     schemas: SchemaMetadata[] | null;
+    /**
+     * The primary decorator associated with this directive.
+     *
+     * If this is `null`, no decorator exists, meaning it's probably from a .d.ts file.
+     */
+    decorator: ts.Decorator | null;
+    /** Additional directives applied to the directive host. */
+    hostDirectives: HostDirectiveMeta[] | null;
+}
+/** Metadata collected about an additional directive that is being applied to a directive host. */
+export interface HostDirectiveMeta {
+    /** Reference to the host directive class. */
+    directive: Reference<ClassDeclaration>;
+    /** Whether the reference to the host directive is a forward reference. */
+    isForwardReference: boolean;
+    /** Inputs from the host directive that have been exposed. */
+    inputs: {
+        [publicName: string]: string;
+    } | null;
+    /** Outputs from the host directive that have been exposed. */
+    outputs: {
+        [publicName: string]: string;
+    } | null;
 }
 /**
  * Metadata that describes a template guard for one of the directive's inputs.
@@ -164,6 +204,7 @@ export interface PipeMeta {
     name: string;
     nameExpr: ts.Expression | null;
     isStandalone: boolean;
+    decorator: ts.Decorator | null;
 }
 /**
  * Reads metadata for directives, pipes, and modules from a particular source, such as .d.ts files

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

@@ -0,0 +1,28 @@
+/*!
+ * @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/metadata/src/host_directives_resolver" />
+import { DirectiveMeta, MetadataReader } from '../../metadata/src/api';
+/** Resolves the host directives of a directive to a flat array of matches. */
+export declare class HostDirectivesResolver {
+    private metaReader;
+    private cache;
+    constructor(metaReader: MetadataReader);
+    /** Resolves all of the host directives that apply to a directive. */
+    resolve(metadata: DirectiveMeta): ReadonlyArray<DirectiveMeta>;
+    /**
+     * Traverses all of the host directive chains and produces a flat array of
+     * directive metadata representing the host directives that apply to the host.
+     */
+    private walkHostDirectives;
+    /**
+     * Filters the class property mappings so that only the allowed ones are present.
+     * @param source Property mappings that should be filtered.
+     * @param allowedProperties Property mappings that are allowed in the final results.
+     */
+    private filterMappings;
+}

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

@@ -12,10 +12,11 @@ import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { DirectiveMeta, DirectiveTypeCheckMeta, MetadataReader, NgModuleMeta, PipeMeta } from './api';
 import { ClassPropertyMapping } from './property_mapping';
 export declare function extractReferencesFromType(checker: ts.TypeChecker, def: ts.TypeNode, bestGuessOwningModule: OwningModule | null): Reference<ClassDeclaration>[];
+export declare function extraReferenceFromTypeQuery(checker: ts.TypeChecker, typeNode: ts.TypeQueryNode, origin: ts.TypeNode, bestGuessOwningModule: OwningModule | null): Reference<ClassDeclaration<ts.ClassDeclaration>>;
 export declare function readBooleanType(type: ts.TypeNode): boolean | null;
 export declare function readStringType(type: ts.TypeNode): string | null;
-export declare function readStringMapType(type: ts.TypeNode): {
-    [key: string]: string;
+export declare function readMapType<T>(type: ts.TypeNode, valueTransform: (type: ts.TypeNode) => T | null): {
+    [key: string]: T;
 };
 export declare function readStringArrayType(type: ts.TypeNode): string[];
 /**

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

@@ -9,7 +9,7 @@
 import { SchemaMetadata, SelectorMatcher } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
-import { DirectiveMeta, MetadataReader } from '../../metadata';
+import { DirectiveMeta, HostDirectivesResolver, MetadataReader } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 import { ComponentScopeReader } from './api';
 /**
@@ -20,7 +20,7 @@ export interface TypeCheckScope {
      * A `SelectorMatcher` instance that contains the flattened directive metadata of all directives
      * that are in the compilation scope of the declaring NgModule.
      */
-    matcher: SelectorMatcher<DirectiveMeta>;
+    matcher: SelectorMatcher<DirectiveMeta[]>;
     /**
      * All of the directives available in the compilation scope of the declaring NgModule.
      */
@@ -45,6 +45,7 @@ export interface TypeCheckScope {
 export declare class TypeCheckScopeRegistry {
     private scopeReader;
     private metaReader;
+    private hostDirectivesResolver;
     /**
      * Cache of flattened directive metadata. Because flattened metadata is scope-invariant it's
      * cached individually, such that all scopes refer to the same flattened metadata.
@@ -54,7 +55,7 @@ export declare class TypeCheckScopeRegistry {
      * Cache of the computed type check scope per NgModule declaration.
      */
     private scopeCache;
-    constructor(scopeReader: ComponentScopeReader, metaReader: MetadataReader);
+    constructor(scopeReader: ComponentScopeReader, metaReader: MetadataReader, hostDirectivesResolver: HostDirectivesResolver);
     /**
      * Computes the type-check scope information for the component declaration. If the NgModule
      * contains an error, then 'error' is returned. If the component is not declared in any NgModule,

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

@@ -0,0 +1,9 @@
+/**
+ * @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/ts_compatibility" />
+export * from './src/ts_cross_version_utils';

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

@@ -0,0 +1,161 @@
+/*!
+ * @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/ts_compatibility/src/ts_cross_version_utils" />
+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;
+/**
+ * Updates a `ts.ParameterDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateParameterDeclaration: Ts48UpdateParameterDeclarationFn;
+/** Type of `ts.factory.updateImportDeclaration` in TS 4.8+. */
+declare type Ts48UpdateImportDeclarationFn = (node: ts.ImportDeclaration, modifiers: readonly ts.Modifier[] | undefined, importClause: ts.ImportClause | undefined, moduleSpecifier: ts.Expression, assertClause: ts.AssertClause | undefined) => ts.ImportDeclaration;
+/**
+ * Updates a `ts.ImportDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateImportDeclaration: Ts48UpdateImportDeclarationFn;
+/** Type of `ts.factory.updateClassDeclaration` in TS 4.8+. */
+declare type Ts48UpdateClassDeclarationFn = (node: ts.ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+/**
+ * Updates a `ts.ClassDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateClassDeclaration: Ts48UpdateClassDeclarationFn;
+/** Type of `ts.factory.createClassDeclaration` in TS 4.8+. */
+declare type Ts48CreateClassDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+/**
+ * Creates a `ts.ClassDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createClassDeclaration: Ts48CreateClassDeclarationFn;
+/** Type of `ts.factory.updateMethodDeclaration` in TS 4.8+. */
+declare type Ts48UpdateMethodDeclarationFn = (node: ts.MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
+/**
+ * Updates a `ts.MethodDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateMethodDeclaration: Ts48UpdateMethodDeclarationFn;
+/** Type of `ts.factory.createMethodDeclaration` in TS 4.8+. */
+declare type Ts48CreateMethodDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
+/**
+ * Creates a `ts.MethodDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createMethodDeclaration: Ts48CreateMethodDeclarationFn;
+/** Type of `ts.factory.updatePropertyDeclaration` in TS 4.8+. */
+declare type Ts48UpdatePropertyDeclarationFn = (node: ts.PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
+/**
+ * Updates a `ts.PropertyDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updatePropertyDeclaration: Ts48UpdatePropertyDeclarationFn;
+/** Type of `ts.factory.createPropertyDeclaration` in TS 4.8+. */
+declare type Ts48CreatePropertyDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
+/**
+ * Creates a `ts.PropertyDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createPropertyDeclaration: Ts48CreatePropertyDeclarationFn;
+/** Type of `ts.factory.updateGetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateGetAccessorDeclarationFn = (node: ts.GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
+/**
+ * Updates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateGetAccessorDeclaration: Ts48UpdateGetAccessorDeclarationFn;
+/** Type of `ts.factory.createGetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48CreateGetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
+/**
+ * Creates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createGetAccessorDeclaration: Ts48CreateGetAccessorDeclarationFn;
+/** Type of `ts.factory.updateSetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateSetAccessorDeclarationFn = (node: ts.SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
+/**
+ * Updates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateSetAccessorDeclaration: Ts48UpdateSetAccessorDeclarationFn;
+/** Type of `ts.factory.createSetAccessorDeclaration` in TS 4.8+. */
+declare type Ts48CreateSetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
+/**
+ * Creates a `ts.GetAccessorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createSetAccessorDeclaration: Ts48CreateSetAccessorDeclarationFn;
+/** Type of `ts.factory.updateConstructorDeclaration` in TS 4.8+. */
+declare type Ts48UpdateConstructorDeclarationFn = (node: ts.ConstructorDeclaration, modifiers: readonly ts.Modifier[] | undefined, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.ConstructorDeclaration;
+/**
+ * Updates a `ts.ConstructorDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const updateConstructorDeclaration: Ts48UpdateConstructorDeclarationFn;
+/**
+ * Gets the decorators that have been applied to a node.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const getDecorators: (node: ts.Node) => readonly ts.Decorator[] | undefined;
+/**
+ * Gets the modifiers that have been set on a node.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const getModifiers: (node: ts.Node) => readonly ts.Modifier[] | undefined;
+/**
+ * Combines an optional array of decorators with an optional array of modifiers into a single
+ * `ts.ModifierLike` array. Used in version of TypeScript after 4.8 where the `decorators` and
+ * `modifiers` arrays have been combined.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare function combineModifiers(decorators: readonly ts.Decorator[] | undefined, modifiers: readonly ModifierLike[] | undefined): readonly ModifierLike[] | undefined;
+export {};

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

@@ -122,6 +122,16 @@ export interface TemplateTypeChecker {
      * the DOM schema.
      */
     getPotentialElementTags(component: ts.ClassDeclaration): Map<string, DirectiveInScope | null>;
+    /**
+     * Get the primary decorator for an Angular class (such as @Component). This does not work for
+     * `@Injectable`.
+     */
+    getPrimaryAngularDecorator(target: ts.ClassDeclaration): ts.Decorator | null;
+    /**
+     * Get the class of the NgModule that owns this Angular trait. If the result is `null`, that
+     * probably means the provided component is standalone.
+     */
+    getOwningNgModule(component: ts.ClassDeclaration): ts.ClassDeclaration | null;
     /**
      * Retrieve any potential DOM bindings for the given element.
      *
@@ -161,16 +171,16 @@ export interface TemplateTypeChecker {
  */
 export declare enum OptimizeFor {
     /**
-     * Indicates that a consumer of a `TemplateTypeChecker` is only interested in results for a given
-     * file, and wants them as fast as possible.
+     * Indicates that a consumer of a `TemplateTypeChecker` is only interested in results for a
+     * given file, and wants them as fast as possible.
      *
      * Calling `TemplateTypeChecker` methods successively for multiple files while specifying
      * `OptimizeFor.SingleFile` can result in significant unnecessary overhead overall.
      */
     SingleFile = 0,
     /**
-     * Indicates that a consumer of a `TemplateTypeChecker` intends to query for results pertaining to
-     * the entire user program, and so the type-checker should internally optimize for this case.
+     * Indicates that a consumer of a `TemplateTypeChecker` intends to query for results pertaining
+     * to the entire user program, and so the type-checker should internally optimize for this case.
      *
      * Initial calls to retrieve type-checking information may take longer, but repeated calls to
      * gather information for the whole user program will be significantly faster with this mode of