@angular/compiler-cli 16.0.0-rc.1 → 16.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "16.0.0-rc.1",
+  "version": "16.0.0-rc.3",
   "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-rc.1",
+    "@angular/compiler": "16.0.0-rc.3",
     "typescript": ">=4.9.3 <5.1"
   },
   "repository": {

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

@@ -8,8 +8,8 @@
 import { Expression, R3ClassMetadata, R3FactoryMetadata, R3InjectorMetadata, R3NgModuleMetadata, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference, ReferenceEmitter } from '../../../imports';
-import { SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
-import { MetadataReader, MetadataRegistry } from '../../../metadata';
+import { SemanticDepGraphUpdater, SemanticReference, SemanticSymbol } from '../../../incremental/semantic_graph';
+import { ExportedProviderStatusResolver, MetadataReader, MetadataRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
@@ -43,11 +43,24 @@ export interface NgModuleResolution {
  * Represents an Angular NgModule.
  */
 export declare class NgModuleSymbol extends SemanticSymbol {
+    readonly hasProviders: boolean;
     private remotelyScopedComponents;
+    /**
+     * `SemanticSymbol`s of the transitive imports of this NgModule which came from imported
+     * standalone components.
+     *
+     * Standalone components are excluded/included in the `InjectorDef` emit output of the NgModule
+     * based on whether the compiler can prove that their transitive imports may contain exported
+     * providers, so a change in this set of symbols may affect the compilation output of this
+     * NgModule.
+     */
+    private transitiveImportsFromStandaloneComponents;
+    constructor(decl: ClassDeclaration, hasProviders: boolean);
     isPublicApiAffected(previousSymbol: SemanticSymbol): boolean;
     isEmitAffected(previousSymbol: SemanticSymbol): boolean;
     isTypeCheckApiAffected(previousSymbol: SemanticSymbol): boolean;
     addRemotelyScopedComponent(component: SemanticSymbol, usedDirectives: SemanticReference[], usedPipes: SemanticReference[]): void;
+    addTransitiveImportFromStandaloneComponent(importedSymbol: SemanticSymbol): void;
 }
 /**
  * Compiles @NgModule annotations to ngModuleDef fields.
@@ -59,18 +72,20 @@ export declare class NgModuleDecoratorHandler implements DecoratorHandler<Decora
     private metaRegistry;
     private scopeRegistry;
     private referencesRegistry;
+    private exportedProviderStatusResolver;
+    private semanticDepGraphUpdater;
     private isCore;
     private refEmitter;
     private annotateForClosureCompiler;
     private onlyPublishPublicTypings;
     private injectableRegistry;
     private perf;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaReader: MetadataReader, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, referencesRegistry: ReferencesRegistry, isCore: boolean, refEmitter: ReferenceEmitter, annotateForClosureCompiler: boolean, onlyPublishPublicTypings: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder);
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaReader: MetadataReader, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, referencesRegistry: ReferencesRegistry, exportedProviderStatusResolver: ExportedProviderStatusResolver, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, isCore: boolean, refEmitter: ReferenceEmitter, annotateForClosureCompiler: boolean, onlyPublishPublicTypings: boolean, injectableRegistry: InjectableClassRegistry, perf: PerfRecorder);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name: string;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator>): AnalysisOutput<NgModuleAnalysis>;
-    symbol(node: ClassDeclaration): NgModuleSymbol;
+    symbol(node: ClassDeclaration, analysis: NgModuleAnalysis): NgModuleSymbol;
     register(node: ClassDeclaration, analysis: NgModuleAnalysis): void;
     resolve(node: ClassDeclaration, analysis: Readonly<NgModuleAnalysis>): ResolveResult<NgModuleResolution>;
     compileFull(node: ClassDeclaration, { inj, mod, fac, classMetadata, declarations, remoteScopesMayRequireCycleProtection }: Readonly<NgModuleAnalysis>, { injectorImports }: Readonly<NgModuleResolution>): CompileResult[];

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

@@ -349,10 +349,13 @@ export interface TargetOptions {
      * Specifies the compilation mode to use. The following modes are available:
      * - 'full': generates fully AOT compiled code using Ivy instructions.
      * - 'partial': generates code in a stable, but intermediate form suitable for publication to NPM.
+     * - 'experimental-local': generates code based on each individual source file without using its
+     * dependencies. This mode is suitable only for fast edit/refresh during development. It will be
+     * eventually replaced by the value `local` once the feature is ready to be public.
      *
      * The default value is 'full'.
      */
-    compilationMode?: 'full' | 'partial';
+    compilationMode?: 'full' | 'partial' | 'experimental-local';
 }
 /**
  * Miscellaneous options that don't fall into any other category

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

@@ -147,13 +147,6 @@ export declare class NgCompiler {
     static fromTicket(ticket: CompilationTicket, adapter: NgCompilerAdapter): NgCompiler;
     private constructor();
     get perfRecorder(): ActivePerfRecorder;
-    /**
-     * Exposes the `IncrementalCompilation` under an old property name that the CLI uses, avoiding a
-     * chicken-and-egg problem with the rename to `incrementalCompilation`.
-     *
-     * TODO(alxhub): remove when the CLI uses the new name.
-     */
-    get incrementalDriver(): IncrementalCompilation;
     private updateWithChangedResources;
     /**
      * Get the resource dependencies of a file.

package/src/ngtsc/incremental/src/strategy.d.ts

@@ -8,16 +8,16 @@
 import ts from 'typescript';
 import { IncrementalState } from './state';
 /**
- * Strategy used to manage the association between a `ts.Program` and the `IncrementalDriver` which
+ * Strategy used to manage the association between a `ts.Program` and the `IncrementalState` which
  * represents the reusable Angular part of its compilation.
  */
 export interface IncrementalBuildStrategy {
     /**
-     * Determine the Angular `IncrementalDriver` for the given `ts.Program`, if one is available.
+     * Determine the Angular `IncrementalState` for the given `ts.Program`, if one is available.
      */
     getIncrementalState(program: ts.Program): IncrementalState | null;
     /**
-     * Associate the given `IncrementalDriver` with the given `ts.Program` and make it available to
+     * Associate the given `IncrementalState` with the given `ts.Program` and make it available to
      * future compilations.
      */
     setIncrementalState(driver: IncrementalState, program: ts.Program): void;
@@ -37,7 +37,7 @@ export declare class NoopIncrementalBuildStrategy implements IncrementalBuildStr
     toNextBuildStrategy(): IncrementalBuildStrategy;
 }
 /**
- * Tracks an `IncrementalDriver` within the strategy itself.
+ * Tracks an `IncrementalState` within the strategy itself.
  */
 export declare class TrackedIncrementalBuildStrategy implements IncrementalBuildStrategy {
     private state;
@@ -47,8 +47,8 @@ export declare class TrackedIncrementalBuildStrategy implements IncrementalBuild
     toNextBuildStrategy(): TrackedIncrementalBuildStrategy;
 }
 /**
- * Manages the `IncrementalDriver` associated with a `ts.Program` by monkey-patching it onto the
- * program under `SYM_INCREMENTAL_DRIVER`.
+ * Manages the `IncrementalState` associated with a `ts.Program` by monkey-patching it onto the
+ * program under `SYM_INCREMENTAL_STATE`.
  */
 export declare class PatchedProgramIncrementalBuildStrategy implements IncrementalBuildStrategy {
     getIncrementalState(program: ts.Program): IncrementalState | null;

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

@@ -12,4 +12,5 @@ export { CompoundMetadataRegistry, LocalMetadataRegistry } from './src/registry'
 export { ResourceRegistry, Resource, ComponentResources, isExternalResource, ExternalResource } from './src/resource_registry';
 export { extractDirectiveTypeCheckMeta, hasInjectableFields, CompoundMetadataReader } from './src/util';
 export { BindingPropertyName, ClassPropertyMapping, ClassPropertyName, InputOrOutput } from './src/property_mapping';
+export { ExportedProviderStatusResolver } from './src/providers';
 export { HostDirectivesResolver } from './src/host_directives_resolver';

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

@@ -47,6 +47,13 @@ export interface NgModuleMeta {
      * If this is `null`, no decorator exists, meaning it's probably from a .d.ts file.
      */
     decorator: ts.Decorator | null;
+    /**
+     * Whether this NgModule may declare providers.
+     *
+     * If the compiler does not know if the NgModule may declare providers, this will be `true` (for
+     * example, NgModules declared outside the current compilation are assumed to declare providers).
+     */
+    mayDeclareProviders: boolean;
 }
 /**
  * Typing metadata collected for a directive within an NgModule's scope.
@@ -165,6 +172,10 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
     decorator: ts.Decorator | null;
     /** Additional directives applied to the directive host. */
     hostDirectives: HostDirectiveMeta[] | null;
+    /**
+     * Whether the directive should be assumed to export providers if imported as a standalone type.
+     */
+    assumedToExportProviders: boolean;
 }
 /** Metadata collected about an additional directive that is being applied to a directive host. */
 export interface HostDirectiveMeta {

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

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Reference } from '../../imports';
+import { ClassDeclaration } from '../../reflection';
+import { MetadataReader } from './api';
+/**
+ * Determines whether types may or may not export providers to NgModules, by transitively walking
+ * the NgModule & standalone import graph.
+ */
+export declare class ExportedProviderStatusResolver {
+    private metaReader;
+    /**
+     * `ClassDeclaration`s that we are in the process of determining the provider status for.
+     *
+     * This is used to detect cycles in the import graph and avoid getting stuck in them.
+     */
+    private calculating;
+    constructor(metaReader: MetadataReader);
+    /**
+     * Determines whether `ref` may or may not export providers to NgModules which import it.
+     *
+     * NgModules export providers if any are declared, and standalone components export providers from
+     * their `imports` array (if any).
+     *
+     * If `true`, then `ref` should be assumed to export providers. In practice, this could mean
+     * either that `ref` is a local type that we _know_ exports providers, or it's imported from a
+     * .d.ts library and is declared in a way where the compiler cannot prove that it doesn't.
+     *
+     * If `false`, then `ref` is guaranteed not to export providers.
+     *
+     * @param `ref` the class for which the provider status should be determined
+     * @param `dependencyCallback` a callback that, if provided, will be called for every type
+     *     which is used in the determination of provider status for `ref`
+     * @returns `true` if `ref` should be assumed to export providers, or `false` if the compiler can
+     *     prove that it does not
+     */
+    mayExportProviders(ref: Reference<ClassDeclaration>, dependencyCallback?: (importRef: Reference<ClassDeclaration>) => void): boolean;
+}

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

@@ -26,7 +26,12 @@ export declare enum CompilationMode {
     /**
      * Generates code using a stable, but intermediate format suitable to be published to NPM.
      */
-    PARTIAL = 1
+    PARTIAL = 1,
+    /**
+     * Generates code based on each individual source file without using its
+     * dependencies (suitable for local dev edit/refresh workflow).
+     */
+    LOCAL = 2
 }
 export declare enum HandlerPrecedence {
     /**