@angular/compiler-cli 16.0.0-next.6 → 16.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "16.0.0-next.6",
+  "version": "16.0.0-rc.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -52,7 +52,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "16.0.0-next.6",
+    "@angular/compiler": "16.0.0-rc.0",
     "typescript": ">=4.9.3 <5.1"
   },
   "repository": {
@@ -66,7 +66,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": "^16.13.0 || >=18.10.0"
+    "node": "^16.14.0 || >=18.10.0"
   },
   "bugs": {
     "url": "https://github.com/angular/angular/issues"

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

@@ -19,9 +19,7 @@ export interface ReferencesRegistry {
     add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void;
 }
 /**
- * This registry does nothing, since ngtsc does not currently need
- * this functionality.
- * The ngcc tool implements a working version for its purposes.
+ * This registry does nothing.
  */
 export declare class NoopReferencesRegistry implements ReferencesRegistry {
     add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void;

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

@@ -20,7 +20,7 @@ import { CompileResult } from '../../../transform';
  */
 export declare function valueReferenceToExpression(valueRef: LocalTypeValueReference | ImportedTypeValueReference): Expression;
 export declare function valueReferenceToExpression(valueRef: TypeValueReference): Expression | null;
-export declare function toR3Reference(origin: ts.Node, valueRef: Reference, typeRef: Reference, valueContext: ts.SourceFile, typeContext: ts.SourceFile, refEmitter: ReferenceEmitter): R3Reference;
+export declare function toR3Reference(origin: ts.Node, ref: Reference, context: ts.SourceFile, refEmitter: ReferenceEmitter): R3Reference;
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
 };
@@ -82,7 +82,7 @@ export declare function resolveProvidersRequiringFactory(rawProviders: ts.Expres
  * Create an R3Reference for a class.
  *
  * The `value` is the exported declaration of the class from its source file.
- * The `type` is an expression that would be used by ngcc in the typings (.d.ts) files.
+ * The `type` is an expression that would be used in the typings (.d.ts) files.
  */
 export declare function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference;
 /** Creates a ParseSourceSpan for a TypeScript node. */

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

@@ -21,7 +21,7 @@ import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerF
 import { TypeCheckContext } from '../../../typecheck/api';
 import { ExtendedTemplateChecker } from '../../../typecheck/extended/api';
 import { Xi18nContext } from '../../../xi18n';
-import { InjectableClassRegistry, ResourceLoader } from '../../common';
+import { InjectableClassRegistry, ReferencesRegistry, ResourceLoader } from '../../common';
 import { ComponentAnalysisData, ComponentResolutionData } from './metadata';
 import { ComponentSymbol } from './symbol';
 /**
@@ -50,13 +50,14 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private cycleAnalyzer;
     private cycleHandlingStrategy;
     private refEmitter;
+    private referencesRegistry;
     private depTracker;
     private injectableRegistry;
     private semanticDepGraphUpdater;
     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, 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);
+    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, referencesRegistry: ReferencesRegistry, 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

@@ -15,7 +15,7 @@ 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 { InjectableClassRegistry, ReferencesRegistry } from '../../common';
 import { DirectiveSymbol } from './symbol';
 export interface DirectiveHandlerData {
     baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
@@ -39,13 +39,13 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     private metaReader;
     private injectableRegistry;
     private refEmitter;
+    private referencesRegistry;
     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, strictCtorDeps: 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, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: 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

@@ -12,13 +12,14 @@ import { ClassPropertyMapping, HostDirectiveMeta, InputMapping } from '../../../
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../../reflection';
 import { HandlerFlags } from '../../../transform';
+import { ReferencesRegistry } from '../../common';
 /**
  * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a
  * selector are allowed to be used for abstract base classes. These abstract directives should not
  * 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, refEmitter: ReferenceEmitter, 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, referencesRegistry: ReferencesRegistry, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
     decorator: Map<string, ts.Expression>;
     metadata: R3DirectiveMetadata;
     inputs: ClassPropertyMapping<InputMapping>;

package/src/ngtsc/partial_evaluator/src/builtin.d.ts

@@ -22,6 +22,3 @@ export declare class StringConcatBuiltinFn extends KnownFn {
     constructor(lhs: string);
     evaluate(node: ts.CallExpression, args: ResolvedValueArray): ResolvedValue;
 }
-export declare class ObjectAssignBuiltinFn extends KnownFn {
-    evaluate(node: ts.CallExpression, args: ResolvedValueArray): ResolvedValue;
-}

package/src/ngtsc/partial_evaluator/src/interpreter.d.ts

@@ -46,7 +46,6 @@ export declare class StaticInterpreter {
     private visitElementAccessExpression;
     private visitPropertyAccessExpression;
     private visitSourceFile;
-    private visitAmbiguousDeclaration;
     private accessHelper;
     private visitCallExpression;
     /**
@@ -65,7 +64,6 @@ export declare class StaticInterpreter {
     private visitSpreadElement;
     private visitBindingElement;
     private stringNameFromPropertyName;
-    private getResolvedEnum;
     private getReference;
     private visitType;
     private visitTupleType;

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

@@ -7,11 +7,9 @@
  */
 import ts from 'typescript';
 /**
- * Metadata extracted from an instance of a decorator on another declaration, or synthesized from
- * other information about a class.
+ * Metadata extracted from an instance of a decorator on another declaration.
  */
-export type Decorator = ConcreteDecorator | SyntheticDecorator;
-export interface BaseDecorator {
+export interface Decorator {
     /**
      * Name by which the decorator was invoked in the user's code.
      *
@@ -22,48 +20,25 @@ export interface BaseDecorator {
     /**
      * Identifier which refers to the decorator in the user's code.
      */
-    identifier: DecoratorIdentifier | null;
+    identifier: DecoratorIdentifier;
     /**
      * `Import` by which the decorator was brought into the module in which it was invoked, or `null`
      * if the decorator was declared in the same module and not imported.
+     *
+     * Note: this field is declared using computed property syntax to work around a clang-format bug
+     * that resulted in inconsistent indentation of this comment block.
      */
-    import: Import | null;
+    ['import']: Import | null;
     /**
-     * TypeScript reference to the decorator itself, or `null` if the decorator is synthesized (e.g.
-     * in ngcc).
+     * TypeScript reference to the decorator itself.
      */
-    node: ts.Node | null;
+    node: ts.Node;
     /**
      * Arguments of the invocation of the decorator, if the decorator is invoked, or `null`
      * otherwise.
      */
     args: ts.Expression[] | null;
 }
-/**
- * Metadata extracted from an instance of a decorator on another declaration, which was actually
- * present in a file.
- *
- * Concrete decorators always have an `identifier` and a `node`.
- */
-export interface ConcreteDecorator extends BaseDecorator {
-    identifier: DecoratorIdentifier;
-    node: ts.Node;
-}
-/**
- * Synthetic decorators never have an `identifier` or a `node`, but know the node for which they
- * were synthesized.
- */
-export interface SyntheticDecorator extends BaseDecorator {
-    identifier: null;
-    node: null;
-    /**
-     * The `ts.Node` for which this decorator was created.
-     */
-    synthesizedFor: ts.Node;
-}
-export declare const Decorator: {
-    nodeForError: (decorator: Decorator) => ts.Node;
-};
 /**
  * A decorator is identified by either a simple identifier (e.g. `Decorator`) or, in some cases,
  * a namespaced property access (e.g. `core.Decorator`).
@@ -382,35 +357,6 @@ export interface FunctionDefinition {
      */
     parameters: Parameter[];
 }
-/**
- * Possible declarations of known values, such as built-in objects/functions or TypeScript helpers.
- */
-export declare enum KnownDeclaration {
-    /**
-     * Indicates the JavaScript global `Object` class.
-     */
-    JsGlobalObject = 0,
-    /**
-     * Indicates the `__assign` TypeScript helper function.
-     */
-    TsHelperAssign = 1,
-    /**
-     * Indicates the `__spread` TypeScript helper function.
-     */
-    TsHelperSpread = 2,
-    /**
-     * Indicates the `__spreadArrays` TypeScript helper function.
-     */
-    TsHelperSpreadArrays = 3,
-    /**
-     * Indicates the `__spreadArray` TypeScript helper function.
-     */
-    TsHelperSpreadArray = 4,
-    /**
-     * Indicates the `__read` TypeScript helper function.
-     */
-    TsHelperRead = 5
-}
 /**
  * A parameter to a function or method.
  */
@@ -444,49 +390,15 @@ export interface Import {
      */
     from: string;
 }
-/**
- * A single enum member extracted from JavaScript when no `ts.EnumDeclaration` is available.
- */
-export interface EnumMember {
-    /**
-     * The name of the enum member.
-     */
-    name: ts.PropertyName;
-    /**
-     * The initializer expression of the enum member. Unlike in TypeScript, this is always available
-     * in emitted JavaScript.
-     */
-    initializer: ts.Expression;
-}
 /**
  * A type that is used to identify a declaration.
- *
- * Declarations are normally `ts.Declaration` types such as variable declarations, class
- * declarations, function declarations etc.
- * But in some cases there is no `ts.Declaration` that can be used for a declaration, such
- * as when they are declared inline as part of an exported expression. Then we must use a
- * `ts.Expression` as the declaration.
- * An example of this is `exports.someVar = 42` where the declaration expression would be
- * `exports.someVar`.
  */
-export type DeclarationNode = ts.Declaration | ts.Expression;
+export type DeclarationNode = ts.Declaration;
 /**
- * The type of a Declaration - whether its node is concrete (ts.Declaration) or inline
- * (ts.Expression). See `ConcreteDeclaration`, `InlineDeclaration` and `DeclarationNode` for more
- * information about this.
- */
-export declare const enum DeclarationKind {
-    Concrete = 0,
-    Inline = 1
-}
-/**
- * Base type for all `Declaration`s.
+ * The declaration of a symbol, along with information about how it was imported into the
+ * application.
  */
-export interface BaseDeclaration<T extends DeclarationNode> {
-    /**
-     * The type of the underlying `node`.
-     */
-    kind: DeclarationKind;
+export interface Declaration<T extends ts.Declaration = ts.Declaration> {
     /**
      * The absolute module path from which the symbol was imported into the application, if the symbol
      * was imported via an absolute module (even through a chain of re-exports). If the symbol is part
@@ -497,53 +409,7 @@ export interface BaseDeclaration<T extends DeclarationNode> {
      * TypeScript reference to the declaration itself, if one exists.
      */
     node: T;
-    /**
-     * If set, describes the type of the known declaration this declaration resolves to.
-     */
-    known: KnownDeclaration | null;
-}
-/**
- * Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
- * `ts.Declaration`).
- */
-export declare function isConcreteDeclaration(decl: Declaration): decl is ConcreteDeclaration;
-export interface ConcreteDeclaration<T extends ts.Declaration = ts.Declaration> extends BaseDeclaration<T> {
-    kind: DeclarationKind.Concrete;
-    /**
-     * Optionally represents a special identity of the declaration, or `null` if the declaration
-     * does not have a special identity.
-     */
-    identity: SpecialDeclarationIdentity | null;
-}
-export type SpecialDeclarationIdentity = DownleveledEnum;
-export declare const enum SpecialDeclarationKind {
-    DownleveledEnum = 0
-}
-/**
- * A special declaration identity that represents an enum. This is used in downleveled forms where
- * a `ts.EnumDeclaration` is emitted in an alternative form, e.g. an IIFE call that declares all
- * members.
- */
-export interface DownleveledEnum {
-    kind: SpecialDeclarationKind.DownleveledEnum;
-    enumMembers: EnumMember[];
 }
-/**
- * A declaration that does not have an associated TypeScript `ts.Declaration`.
- *
- * This can occur in some downlevelings when an `export const VAR = ...;` (a `ts.Declaration`) is
- * transpiled to an assignment statement (e.g. `exports.VAR = ...;`). There is no `ts.Declaration`
- * associated with `VAR` in that case, only an expression.
- */
-export interface InlineDeclaration extends BaseDeclaration<Exclude<DeclarationNode, ts.Declaration>> {
-    kind: DeclarationKind.Inline;
-    implementation?: DeclarationNode;
-}
-/**
- * The declaration of a symbol, along with information about how it was imported into the
- * application.
- */
-export type Declaration<T extends ts.Declaration = ts.Declaration> = ConcreteDeclaration<T> | InlineDeclaration;
 /**
  * Abstracts reflection operations on a TypeScript AST.
  *
@@ -710,37 +576,6 @@ export interface ReflectionHost {
      * if the value cannot be computed.
      */
     getVariableValue(declaration: ts.VariableDeclaration): ts.Expression | null;
-    /**
-     * Take an exported declaration (maybe a class down-leveled to a variable) and look up the
-     * declaration of its type in a separate .d.ts tree.
-     *
-     * This function is allowed to return `null` if the current compilation unit does not have a
-     * separate .d.ts tree. When compiling TypeScript code this is always the case, since .d.ts files
-     * are produced only during the emit of such a compilation. When compiling .js code, however,
-     * there is frequently a parallel .d.ts tree which this method exposes.
-     *
-     * Note that the `ts.Declaration` returned from this function may not be from the same
-     * `ts.Program` as the input declaration.
-     */
-    getDtsDeclaration(declaration: DeclarationNode): ts.Declaration | null;
-    /**
-     * Get a `ts.Identifier` for a given `ClassDeclaration` which can be used to refer to the class
-     * within its definition (such as in static fields).
-     *
-     * This can differ from `clazz.name` when ngcc runs over ES5 code, since the class may have a
-     * different name within its IIFE wrapper than it does externally.
-     */
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    /**
-     * Get a `ts.Identifier` for a given `ClassDeclaration` which can be used to refer to the class
-     * from statements that are "adjacent", and conceptually tightly bound, to the class but not
-     * actually inside it.
-     *
-     * Similar to `getInternalNameOfClass()`, this name can differ from `clazz.name` when ngcc runs
-     * over ES5 code, since these "adjacent" statements need to exist in the IIFE where the class may
-     * have a different name than it does externally.
-     */
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
     /**
      * Returns `true` if a declaration is exported from the module in which it's defined.
      *

package/src/ngtsc/reflection/src/typescript.d.ts

@@ -25,9 +25,6 @@ export declare class TypeScriptReflectionHost implements ReflectionHost {
     getDefinitionOfFunction(node: ts.Node): FunctionDefinition | null;
     getGenericArityOfClass(clazz: ClassDeclaration): number | null;
     getVariableValue(declaration: ts.VariableDeclaration): ts.Expression | null;
-    getDtsDeclaration(_: ClassDeclaration): ts.Declaration | null;
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
     isStaticallyExported(decl: ts.Node): boolean;
     protected getDirectImportOfIdentifier(id: ts.Identifier): Import | null;
     /**

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

@@ -16,7 +16,7 @@ import { ClassDeclaration, DeclarationNode, Decorator, ReflectionHost } from '..
 import { ProgramTypeCheckAdapter, TypeCheckContext } from '../../typecheck/api';
 import { ExtendedTemplateChecker } from '../../typecheck/extended/api';
 import { Xi18nContext } from '../../xi18n';
-import { CompilationMode, CompileResult, DecoratorHandler, HandlerFlags } from './api';
+import { CompilationMode, CompileResult, DecoratorHandler } from './api';
 import { DtsTransformRegistry } from './declaration';
 import { PendingTrait, Trait } from './trait';
 /**
@@ -75,12 +75,12 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
      * Maps source files to any class declaration(s) within them which have been discovered to contain
      * Ivy traits.
      */
-    protected fileToClasses: Map<ts.SourceFile, Set<ClassDeclaration>>;
+    private fileToClasses;
     /**
      * Tracks which source files have been analyzed but did not contain any traits. This set allows
      * the compiler to skip analyzing these files in an incremental rebuild.
      */
-    protected filesWithoutTraits: Set<ts.SourceFile>;
+    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);
@@ -88,7 +88,6 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     analyzeAsync(sf: ts.SourceFile): Promise<void> | undefined;
     private analyze;
     recordFor(clazz: ClassDeclaration): ClassRecord | null;
-    recordsFor(sf: ts.SourceFile): ClassRecord[] | null;
     getAnalyzedRecords(): Map<ts.SourceFile, ClassRecord[]>;
     /**
      * Import a `ClassRecord` from a previous compilation.
@@ -102,8 +101,8 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     private scanClassForTraits;
     protected detectTraits(clazz: ClassDeclaration, decorators: Decorator[] | null): PendingTrait<unknown, unknown, SemanticSymbol | null, unknown>[] | null;
     private makeSymbolForTrait;
-    protected analyzeClass(clazz: ClassDeclaration, preanalyzeQueue: Promise<void>[] | null): void;
-    protected analyzeTrait(clazz: ClassDeclaration, trait: Trait<unknown, unknown, SemanticSymbol | null, unknown>, flags?: HandlerFlags): void;
+    private analyzeClass;
+    private analyzeTrait;
     resolve(): void;
     /**
      * Generate type-checking code into the `TypeCheckContext` for any components within the given