@angular/compiler-cli 20.0.1 → 20.1.0-next.0

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { DirectiveMeta as T2DirectiveMeta, Expression, SchemaMetadata } from '@angular/compiler';
+import { DirectiveMeta as T2DirectiveMeta, Expression, SchemaMetadata, ExternalReference } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
 import { ClassDeclaration } from '../../reflection';
@@ -241,6 +241,12 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * scope via `@Component.deferredImports` field.
      */
     isExplicitlyDeferred: boolean;
+    /** Whether selectorless is enabled for the specific component. */
+    selectorlessEnabled: boolean;
+    /**
+     * Names of the symbols within the source file that are referenced directly inside the template.
+     */
+    localReferencedSymbols: Set<string> | null;
 }
 /** Metadata collected about an additional directive that is being applied to a directive host. */
 export interface HostDirectiveMeta {
@@ -251,7 +257,7 @@ export interface HostDirectiveMeta {
      * which indicates the expression could not be resolved due to being imported from some external
      * file. In this case, the expression is the raw expression as appears in the decorator.
      */
-    directive: Reference<ClassDeclaration> | Expression;
+    directive: Reference<ClassDeclaration> | Expression | ExternalReference;
     /** Whether the reference to the host directive is a forward reference. */
     isForwardReference: boolean;
     /** Inputs from the host directive that have been exposed. */
@@ -300,7 +306,7 @@ export interface TemplateGuardMeta {
 export interface PipeMeta {
     kind: MetaKind.Pipe;
     ref: Reference<ClassDeclaration>;
-    name: string;
+    name: string | null;
     nameExpr: ts.Expression | null;
     isStandalone: boolean;
     isPure: boolean;

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

@@ -5,9 +5,10 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-export { ComponentScopeKind, ComponentScopeReader, ExportScope, LocalModuleScope, ScopeData, StandaloneScope, } from './src/api';
+export { ComponentScopeKind, ComponentScopeReader, ExportScope, LocalModuleScope, ScopeData, StandaloneScope, ComponentScope, } from './src/api';
 export { CompoundComponentScopeReader } from './src/component_scope';
 export { DtsModuleScopeResolver, MetadataDtsModuleScopeResolver } from './src/dependency';
 export { DeclarationData, LocalModuleScopeRegistry, LocalNgModuleData } from './src/local';
+export { SelectorlessComponentScopeReader } from './src/selectorless_scope';
 export { TypeCheckScope, TypeCheckScopeRegistry } from './src/typecheck';
 export { makeNotStandaloneDiagnostic, makeUnknownComponentImportDiagnostic } from './src/util';

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

@@ -9,6 +9,7 @@ import { SchemaMetadata } from '@angular/compiler';
 import { Reexport, Reference } from '../../imports';
 import { DirectiveMeta, NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
+import ts from 'typescript';
 /**
  * Data for one of a given NgModule's scopes (either compilation scope or export scopes).
  */
@@ -46,7 +47,8 @@ export interface RemoteScope {
 }
 export declare enum ComponentScopeKind {
     NgModule = 0,
-    Standalone = 1
+    Standalone = 1,
+    Selectorless = 2
 }
 export interface LocalModuleScope extends ExportScope {
     kind: ComponentScopeKind.NgModule;
@@ -63,7 +65,15 @@ export interface StandaloneScope {
     schemas: SchemaMetadata[];
     isPoisoned: boolean;
 }
-export type ComponentScope = LocalModuleScope | StandaloneScope;
+export interface SelectorlessScope {
+    kind: ComponentScopeKind.Selectorless;
+    dependencies: Map<string, DirectiveMeta | PipeMeta>;
+    dependencyIdentifiers: ts.Identifier[];
+    component: ClassDeclaration;
+    schemas: SchemaMetadata[];
+    isPoisoned: boolean;
+}
+export type ComponentScope = LocalModuleScope | StandaloneScope | SelectorlessScope;
 /**
  * Read information about the compilation scope of components.
  */

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

@@ -0,0 +1,25 @@
+/**
+ * @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.dev/license
+ */
+import { MetadataReader } from '../../metadata';
+import { ClassDeclaration, ReflectionHost } from '../../reflection';
+import { ComponentScopeReader, SelectorlessScope } from './api';
+/**
+ * Computes the scope for a selectorless component by looking at imports within the same
+ * file and resolving them to metadata.
+ */
+export declare class SelectorlessComponentScopeReader implements ComponentScopeReader {
+    private metaReader;
+    private reflector;
+    private cache;
+    constructor(metaReader: MetadataReader, reflector: ReflectionHost);
+    getScopeForComponent(node: ClassDeclaration): SelectorlessScope | null;
+    getRemoteScope(): null;
+    /** Determines which identifiers a class has access to. */
+    private getAvailableIdentifiers;
+    private getMetaFromIdentifier;
+}

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { SchemaMetadata, SelectorMatcher } from '@angular/compiler';
+import { DirectiveMatcher, SchemaMetadata } from '@angular/compiler';
 import { Reference } from '../../imports';
 import { DirectiveMeta, HostDirectivesResolver, MetadataReader, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
@@ -15,10 +15,10 @@ import { ComponentScopeReader } from './api';
  */
 export interface TypeCheckScope {
     /**
-     * A `SelectorMatcher` instance that contains the flattened directive metadata of all directives
+     * A `DirectiveMatcher` instance that contains the flattened directive metadata of all directives
      * that are in the compilation scope of the declaring NgModule.
      */
-    matcher: SelectorMatcher<DirectiveMeta[]>;
+    matcher: DirectiveMatcher<DirectiveMeta> | null;
     /**
      * All of the directives available in the compilation scope of the declaring NgModule.
      */
@@ -62,4 +62,6 @@ export declare class TypeCheckScopeRegistry {
     getTypeCheckScope(node: ClassDeclaration): TypeCheckScope;
     getTypeCheckDirectiveMetadata(ref: Reference<ClassDeclaration>): DirectiveMeta | null;
     private applyExplicitlyDeferredFlag;
+    private getSelectorMatcher;
+    private getSelectorlessMatcher;
 }

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

@@ -11,3 +11,4 @@ export { ClassRecord, TraitCompiler } from './src/compilation';
 export { declarationTransformFactory, DtsTransformRegistry, IvyDeclarationDtsTransform, } from './src/declaration';
 export { AnalyzedTrait, PendingTrait, ResolvedTrait, SkippedTrait, Trait, TraitState, } from './src/trait';
 export { ivyTransformFactory } from './src/transform';
+export { signalMetadataTransform } from './src/implicit_signal_debug_name_transform';

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

@@ -221,7 +221,5 @@ export interface ResolveResult<R> {
     data?: Readonly<R>;
 }
 export interface DtsTransform {
-    transformClassElement?(element: ts.ClassElement, imports: ImportManager): ts.ClassElement;
-    transformFunctionDeclaration?(element: ts.FunctionDeclaration, imports: ImportManager): ts.FunctionDeclaration;
     transformClass?(clazz: ts.ClassDeclaration, elements: ReadonlyArray<ts.ClassElement>, reflector: ReflectionHost, refEmitter: ReferenceEmitter, imports: ImportManager): ts.ClassDeclaration;
 }

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

@@ -65,6 +65,7 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     private dtsTransforms;
     private semanticDepGraphUpdater;
     private sourceFileTypeIdentifier;
+    private emitDeclarationOnly;
     /**
      * Maps class declarations to their `ClassRecord`, which tracks the Ivy traits being applied to
      * those classes.
@@ -82,7 +83,7 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     private filesWithoutTraits;
     private reexportMap;
     private handlersByName;
-    constructor(handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[], reflector: ReflectionHost, perf: PerfRecorder, incrementalBuild: IncrementalBuild<ClassRecord, unknown>, compileNonExportedClasses: boolean, compilationMode: CompilationMode, dtsTransforms: DtsTransformRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, sourceFileTypeIdentifier: SourceFileTypeIdentifier);
+    constructor(handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[], reflector: ReflectionHost, perf: PerfRecorder, incrementalBuild: IncrementalBuild<ClassRecord, unknown>, compileNonExportedClasses: boolean, compilationMode: CompilationMode, dtsTransforms: DtsTransformRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, sourceFileTypeIdentifier: SourceFileTypeIdentifier, emitDeclarationOnly: boolean);
     analyzeSync(sf: ts.SourceFile): void;
     analyzeAsync(sf: ts.SourceFile): Promise<void> | undefined;
     private analyze;

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

@@ -0,0 +1,74 @@
+/**
+ * @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.dev/license
+ */
+import ts from 'typescript';
+/**
+ *
+ * This transformer adds a debugName property to the config object of signal functions like
+ * signal, computed, effect, etc.
+ *
+ * The debugName property is added conditionally based on the value of ngDevMode. This is done
+ * to avoid adding the debugName property in production builds.
+ *
+ * Ex:
+ * ```ts
+ * import {signal} from '@angular/core';
+ * const mySignal = signal('Hello World');
+ * ```
+ *
+ * is transformed to:
+ * ```ts
+ * import {signal} from '@angular/core';
+ * const mySignal = signal('Hello World', ...(ngDevMode ? [{ debugName: "mySignal" }] : []));
+ * ```
+ *
+ * The transformer supports the following cases:
+ *
+ * # Variable declaration
+ * ```ts
+ * const mySignal = signal('Hello World');
+ * ```
+ *
+ * becomes
+ * ```
+ * const  mySignal = signal('Hello World', ...(ngDevMode ? [{ debugName: "mySignal" }] : []));
+ * ```
+ *
+ * # Property assignment
+ * ```ts
+ * class MyClass {
+ *  mySignal: Signal<string>;
+ *  constructor() {
+ *    this.mySignal = signal('Hello World');
+ *  }
+ * }
+ * ```
+ * becomes
+ * ```ts
+ * class MyClass {
+ *  mySignal: Signal<string>;
+ *  constructor() {
+ *   this.mySignal = signal(...(ngDevMode ? ['Hello World', { debugName: "mySignal" }] : ['Hello World']));
+ *  }
+ * }
+ * ```
+ *
+ * # Property declaration
+ * ```ts
+ * class MyClass {
+ *   mySignal = signal('Hello World');
+ * }
+ * ```
+ * becomes
+ * ```ts
+ * class MyClass {
+ *  mySignal = signal(...(ngDevMode ? ['Hello World', { debugName: "mySignal" }] : ['Hello World']));
+ * }
+ * ```
+ *
+ */
+export declare function signalMetadataTransform(program: ts.Program): ts.TransformerFactory<ts.SourceFile>;

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

@@ -10,4 +10,4 @@ import { DefaultImportTracker, ImportRewriter, LocalCompilationExtraImportsTrack
 import { PerfRecorder } from '../../perf';
 import { ReflectionHost } from '../../reflection';
 import { TraitCompiler } from './compilation';
-export declare function ivyTransformFactory(compilation: TraitCompiler, reflector: ReflectionHost, importRewriter: ImportRewriter, defaultImportTracker: DefaultImportTracker, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, perf: PerfRecorder, isCore: boolean, isClosureCompilerEnabled: boolean): ts.TransformerFactory<ts.SourceFile>;
+export declare function ivyTransformFactory(compilation: TraitCompiler, reflector: ReflectionHost, importRewriter: ImportRewriter, defaultImportTracker: DefaultImportTracker, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, perf: PerfRecorder, isCore: boolean, isClosureCompilerEnabled: boolean, emitDeclarationOnly: boolean): ts.TransformerFactory<ts.SourceFile>;

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

@@ -30,9 +30,6 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     visitReturnStmt(stmt: o.ReturnStatement, context: Context): TStatement;
     visitIfStmt(stmt: o.IfStmt, context: Context): TStatement;
     visitReadVarExpr(ast: o.ReadVarExpr, _context: Context): TExpression;
-    visitWriteVarExpr(expr: o.WriteVarExpr, context: Context): TExpression;
-    visitWriteKeyExpr(expr: o.WriteKeyExpr, context: Context): TExpression;
-    visitWritePropExpr(expr: o.WritePropExpr, context: Context): TExpression;
     visitInvokeFunctionExpr(ast: o.InvokeFunctionExpr, context: Context): TExpression;
     visitTaggedTemplateLiteralExpr(ast: o.TaggedTemplateLiteralExpr, context: Context): TExpression;
     visitTemplateLiteralExpr(ast: o.TemplateLiteralExpr, context: Context): TExpression;

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

@@ -361,3 +361,6 @@ export interface FullSourceMapping {
     sourceMapping: SourceMapping;
     span: ParseSourceSpan;
 }
+export interface GetPotentialAngularMetaOptions {
+    includeExternalModule: boolean;
+}

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

@@ -5,17 +5,17 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
 import { ErrorCode } from '../../diagnostics';
 import { Reference } from '../../imports';
 import { NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
-import { FullSourceMapping, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
+import { FullSourceMapping, GetPotentialAngularMetaOptions, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
 import { GlobalCompletion } from './completion';
-import { PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe } from './scope';
-import { ElementSymbol, Symbol, TcbLocation, TemplateSymbol } from './symbols';
+import { PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe, TsCompletionEntryInfo } from './scope';
+import { ElementSymbol, SelectorlessComponentSymbol, SelectorlessDirectiveSymbol, Symbol, TcbLocation, TemplateSymbol } from './symbols';
 /**
  * Interface to the Angular Template Type Checker to extract diagnostics and intelligence from the
  * compiler's understanding of component templates.
@@ -92,6 +92,8 @@ export interface TemplateTypeChecker {
      */
     getSymbolOfNode(node: TmplAstElement, component: ts.ClassDeclaration): ElementSymbol | null;
     getSymbolOfNode(node: TmplAstTemplate, component: ts.ClassDeclaration): TemplateSymbol | null;
+    getSymbolOfNode(node: TmplAstComponent, component: ts.ClassDeclaration): SelectorlessComponentSymbol | null;
+    getSymbolOfNode(node: TmplAstDirective, component: ts.ClassDeclaration): SelectorlessDirectiveSymbol | null;
     getSymbolOfNode(node: AST | TmplAstNode, component: ts.ClassDeclaration): Symbol | null;
     /**
      * Get "global" `Completion`s in the given context.
@@ -103,6 +105,10 @@ export interface TemplateTypeChecker {
      * template variables which are in scope for that expression.
      */
     getGlobalCompletions(context: TmplAstTemplate | null, component: ts.ClassDeclaration, node: AST | TmplAstNode): GlobalCompletion | null;
+    /**
+     * Get the `TcbLocation` for the global context, which is the location of the `this` variable.
+     */
+    getGlobalTsContext(component: ts.ClassDeclaration): TcbLocation | null;
     /**
      * For the given expression node, retrieve a `TcbLocation` that can be used to perform
      * autocompletion at that point in the expression, if such a location exists.
@@ -118,7 +124,7 @@ export interface TemplateTypeChecker {
      * Get basic metadata on the directives which are in scope or can be imported for the given
      * component.
      */
-    getPotentialTemplateDirectives(component: ts.ClassDeclaration): PotentialDirective[];
+    getPotentialTemplateDirectives(component: ts.ClassDeclaration, tsLs: ts.LanguageService, options: GetPotentialAngularMetaOptions): PotentialDirective[];
     /**
      * Get basic metadata on the pipes which are in scope or can be imported for the given component.
      */
@@ -128,7 +134,19 @@ export interface TemplateTypeChecker {
      * 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, PotentialDirective | null>;
+    getPotentialElementTags(component: ts.ClassDeclaration, tsLs: ts.LanguageService, options: GetPotentialAngularMetaOptions): Map<string, PotentialDirective | null>;
+    /**
+     * Retrieve a `Map` of potential template element tags that includes in the current component's file
+     * scope, or in the component's NgModule scope.
+     *
+     * The different with the `getPotentialElementTags` is that the directives in the map do not need
+     * to update the import statement.
+     */
+    getElementsInFileScope(component: ts.ClassDeclaration): Map<string, PotentialDirective | null>;
+    /**
+     * Get the scope data for a directive.
+     */
+    getDirectiveScopeData(component: ts.ClassDeclaration, isInScope: boolean, tsCompletionEntryInfo: TsCompletionEntryInfo | null): PotentialDirective | null;
     /**
      * In the context of an Angular trait, generate potential imports for a directive.
      */

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

@@ -26,6 +26,20 @@ export declare enum PotentialImportKind {
     NgModule = 0,
     Standalone = 1
 }
+export interface TsCompletionEntryInfo {
+    /**
+     * Sometimes, the location of the tsCompletionEntry symbol does not match the location of the Angular symbol.
+     *
+     * For example, the BarComponent is declared in `bar.ts` and exported from there. The `public_api.ts` also
+     * reexports the BarComponent from `bar.ts`, so the `tsCompletionEntrySymbolFileName` will be `public_api.ts`.
+     */
+    tsCompletionEntrySymbolFileName: string;
+    /**
+     * This data is from the tsLs completion entry, and
+     * will be used in the `ls.getCompletionEntryDetails`.
+     */
+    tsCompletionEntryData?: ts.CompletionEntryData;
+}
 /**
  * Metadata on a directive which is available in a template.
  */
@@ -55,6 +69,7 @@ export interface PotentialDirective {
      * Whether or not this directive is in scope.
      */
     isInScope: boolean;
+    tsCompletionEntryInfo: TsCompletionEntryInfo | null;
 }
 /**
  * Metadata for a pipe which is available in a template.
@@ -68,11 +83,12 @@ export interface PotentialPipe {
     /**
      * Name of the pipe.
      */
-    name: string;
+    name: string | null;
     /**
      * Whether or not this pipe is in scope.
      */
     isInScope: boolean;
+    tsCompletionEntryInfo: TsCompletionEntryInfo | null;
 }
 /**
  * Possible modes in which to look up a potential import.

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { TmplAstElement, TmplAstLetDeclaration, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import { TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstLetDeclaration, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { SymbolWithValueDeclaration } from '../../util/src/typescript';
@@ -22,12 +22,14 @@ export declare enum SymbolKind {
     Expression = 8,
     DomBinding = 9,
     Pipe = 10,
-    LetDeclaration = 11
+    LetDeclaration = 11,
+    SelectorlessComponent = 12,
+    SelectorlessDirective = 13
 }
 /**
  * A representation of an entity in the `TemplateAst`.
  */
-export type Symbol = InputBindingSymbol | OutputBindingSymbol | ElementSymbol | ReferenceSymbol | VariableSymbol | ExpressionSymbol | DirectiveSymbol | TemplateSymbol | DomBindingSymbol | PipeSymbol | LetDeclarationSymbol;
+export type Symbol = InputBindingSymbol | OutputBindingSymbol | ElementSymbol | ReferenceSymbol | VariableSymbol | ExpressionSymbol | DirectiveSymbol | TemplateSymbol | DomBindingSymbol | PipeSymbol | LetDeclarationSymbol | SelectorlessComponentSymbol | SelectorlessDirectiveSymbol;
 /**
  * A `Symbol` which declares a new named entity in the template scope.
  */
@@ -234,6 +236,40 @@ export interface TemplateSymbol {
     directives: DirectiveSymbol[];
     templateNode: TmplAstTemplate;
 }
+/** A representation of a selectorless component reference in a template. */
+export interface SelectorlessComponentSymbol {
+    kind: SymbolKind.SelectorlessComponent;
+    /** The `ts.Type` for the component class. */
+    tsType: ts.Type;
+    /** The `ts.Symbol` for the component class. */
+    tsSymbol: ts.Symbol | null;
+    /**
+     * Includes the component class itself and any host directives
+     * that may have been applied as a side-effect of it.
+     */
+    directives: DirectiveSymbol[];
+    /** The location in the shim file for the variable that holds the type of the component. */
+    tcbLocation: TcbLocation;
+    /** Template AST node defining the component. */
+    templateNode: TmplAstComponent;
+}
+/** A representation of a selectorless directive reference in a template. */
+export interface SelectorlessDirectiveSymbol {
+    kind: SymbolKind.SelectorlessDirective;
+    /** The `ts.Type` for the directive class. */
+    tsType: ts.Type;
+    /** The `ts.Symbol` for the directive class. */
+    tsSymbol: ts.Symbol | null;
+    /**
+     * Includes the directive class itself and any host directives
+     * that may have been applied as a side-effect of it.
+     */
+    directives: DirectiveSymbol[];
+    /** The location in the shim file for the variable that holds the type of the directive. */
+    tcbLocation: TcbLocation;
+    /** Template AST node defining the directive. */
+    templateNode: TmplAstDirective;
+}
 /** Interface shared between host and non-host directives. */
 interface DirectiveSymbolBase extends PotentialDirective {
     kind: SymbolKind.Directive;

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { ErrorCode } from '../../diagnostics';
 import { AbsoluteFsPath } from '../../file_system';
@@ -16,7 +16,7 @@ import { PerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ComponentScopeReader, TypeCheckScopeRegistry } from '../../scope';
-import { ElementSymbol, FullSourceMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { ElementSymbol, FullSourceMapping, GetPotentialAngularMetaOptions, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe, ProgramTypeCheckAdapter, SelectorlessComponentSymbol, SelectorlessDirectiveSymbol, TcbLocation, TemplateSymbol, TemplateTypeChecker, TsCompletionEntryInfo, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
 import { ShimTypeCheckingData } from './context';
 import { DirectiveSourceManager } from './source';
 /**
@@ -121,13 +121,20 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getFileData(path: AbsoluteFsPath): FileTypeCheckingData;
     getSymbolOfNode(node: TmplAstTemplate, component: ts.ClassDeclaration): TemplateSymbol | null;
     getSymbolOfNode(node: TmplAstElement, component: ts.ClassDeclaration): ElementSymbol | null;
+    getSymbolOfNode(node: TmplAstComponent, component: ts.ClassDeclaration): SelectorlessComponentSymbol | null;
+    getSymbolOfNode(node: TmplAstDirective, component: ts.ClassDeclaration): SelectorlessDirectiveSymbol | null;
     private getOrCreateSymbolBuilder;
-    getPotentialTemplateDirectives(component: ts.ClassDeclaration): PotentialDirective[];
+    getGlobalTsContext(component: ts.ClassDeclaration): TcbLocation | null;
+    getPotentialTemplateDirectives(component: ts.ClassDeclaration, tsLs: ts.LanguageService, options: GetPotentialAngularMetaOptions): PotentialDirective[];
     getPotentialPipes(component: ts.ClassDeclaration): PotentialPipe[];
     getDirectiveMetadata(dir: ts.ClassDeclaration): TypeCheckableDirectiveMeta | null;
     getNgModuleMetadata(module: ts.ClassDeclaration): NgModuleMeta | null;
     getPipeMetadata(pipe: ts.ClassDeclaration): PipeMeta | null;
-    getPotentialElementTags(component: ts.ClassDeclaration): Map<string, PotentialDirective | null>;
+    getTemplateDirectiveInScope(component: ts.ClassDeclaration): PotentialDirective[];
+    getDirectiveScopeData(component: ts.ClassDeclaration, isInScope: boolean, tsCompletionEntryInfo: TsCompletionEntryInfo | null): PotentialDirective | null;
+    getElementsInFileScope(component: ts.ClassDeclaration): Map<string, PotentialDirective | null>;
+    getElementsInGlobal(component: ts.ClassDeclaration, tsLs: ts.LanguageService, options: GetPotentialAngularMetaOptions): PotentialDirective[];
+    getPotentialElementTags(component: ts.ClassDeclaration, tsLs: ts.LanguageService, options: GetPotentialAngularMetaOptions): Map<string, PotentialDirective | null>;
     getPotentialDomBindings(tagName: string): {
         attribute: string;
         property: string;
@@ -137,6 +144,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getOwningNgModule(component: ts.ClassDeclaration): ts.ClassDeclaration | null;
     private emit;
     getPotentialImportsFor(toImport: Reference<ClassDeclaration>, inContext: ts.Node, importMode: PotentialImportMode): ReadonlyArray<PotentialImport>;
+    private getComponentScope;
     private getScopeData;
     private scopeDataOfDirectiveMeta;
     private scopeDataOfPipeMeta;

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AST, LiteralPrimitive, PropertyRead, PropertyWrite, SafePropertyRead, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import { AST, LiteralPrimitive, PropertyRead, SafePropertyRead, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { GlobalCompletion, TcbLocation } from '../api';
@@ -22,6 +22,10 @@ export declare class CompletionEngine {
     private tcbPath;
     private tcbIsShim;
     private componentContext;
+    /**
+     * Get the `TcbLocation` for the global context, which is the location of the `this` variable.
+     */
+    private globalTsContext;
     /**
      * Cache of completions for various levels of the template, including the root template (`null`).
      * Memoizes `getTemplateContextCompletions`.
@@ -29,6 +33,7 @@ export declare class CompletionEngine {
     private templateContextCache;
     private expressionCompletionCache;
     constructor(tcb: ts.Node, data: TypeCheckData, tcbPath: AbsoluteFsPath, tcbIsShim: boolean);
+    getGlobalTsContext(): TcbLocation | null;
     /**
      * Get global completions within the given template context and AST node.
      *
@@ -38,7 +43,7 @@ export declare class CompletionEngine {
      * @param node the given AST node
      */
     getGlobalCompletions(context: TmplAstTemplate | null, node: AST | TmplAstNode): GlobalCompletion | null;
-    getExpressionCompletionLocation(expr: PropertyRead | PropertyWrite | SafePropertyRead): TcbLocation | null;
+    getExpressionCompletionLocation(expr: PropertyRead | SafePropertyRead): TcbLocation | null;
     getLiteralCompletionLocation(expr: LiteralPrimitive | TmplAstTextAttribute): TcbLocation | null;
     /**
      * Get global completions within the given template context - either a `TmplAstTemplate` embedded

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { BindingPipe, PropertyRead, PropertyWrite, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstTextAttribute, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
+import { BindingPipe, PropertyRead, AST, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstTextAttribute, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration } from '../../reflection';
 import { TemplateDiagnostic, TypeCheckId } from '../api';
@@ -88,7 +88,7 @@ export interface OutOfBandDiagnosticRecorder {
      */
     controlFlowPreventingContentProjection(id: TypeCheckId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
     /** Reports cases where users are writing to `@let` declarations. */
-    illegalWriteToLetDeclaration(id: TypeCheckId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
+    illegalWriteToLetDeclaration(id: TypeCheckId, node: AST, target: TmplAstLetDeclaration): void;
     /** Reports cases where users are accessing an `@let` before it is defined.. */
     letUsedBeforeDefinition(id: TypeCheckId, node: PropertyRead, target: TmplAstLetDeclaration): void;
     /**
@@ -152,7 +152,7 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
     inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
     controlFlowPreventingContentProjection(id: TypeCheckId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
-    illegalWriteToLetDeclaration(id: TypeCheckId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
+    illegalWriteToLetDeclaration(id: TypeCheckId, node: AST, target: TmplAstLetDeclaration): void;
     letUsedBeforeDefinition(id: TypeCheckId, node: PropertyRead, target: TmplAstLetDeclaration): void;
     conflictingDeclaration(id: TypeCheckId, decl: TmplAstLetDeclaration): void;
     missingNamedTemplateDependency(id: TypeCheckId, node: TmplAstComponent | TmplAstDirective): void;

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

@@ -5,11 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AST, TmplAstElement, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import { AST, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { ComponentScopeReader } from '../../scope';
-import { ElementSymbol, LetDeclarationSymbol, ReferenceSymbol, Symbol, TemplateSymbol, VariableSymbol } from '../api';
+import { ElementSymbol, LetDeclarationSymbol, ReferenceSymbol, SelectorlessComponentSymbol, SelectorlessDirectiveSymbol, Symbol, TemplateSymbol, VariableSymbol } from '../api';
 import { TypeCheckData } from './context';
 /**
  * Generates and caches `Symbol`s for various template structures for a given component.
@@ -28,9 +28,13 @@ export declare class SymbolBuilder {
     constructor(tcbPath: AbsoluteFsPath, tcbIsShim: boolean, typeCheckBlock: ts.Node, typeCheckData: TypeCheckData, componentScopeReader: ComponentScopeReader, getTypeChecker: () => ts.TypeChecker);
     getSymbol(node: TmplAstTemplate | TmplAstElement): TemplateSymbol | ElementSymbol | null;
     getSymbol(node: TmplAstReference | TmplAstVariable | TmplAstLetDeclaration): ReferenceSymbol | VariableSymbol | LetDeclarationSymbol | null;
+    getSymbol(node: TmplAstComponent): SelectorlessComponentSymbol | null;
+    getSymbol(node: TmplAstDirective): SelectorlessDirectiveSymbol | null;
     getSymbol(node: AST | TmplAstNode): Symbol | null;
     private getSymbolOfAstTemplate;
     private getSymbolOfElement;
+    private getSymbolOfSelectorlessComponent;
+    private getSymbolOfSelectorlessDirective;
     private getDirectivesOfNode;
     private addHostDirectiveSymbols;
     private getDirectiveMeta;