refactor(@angular/build): eliminate NoopCompilation and introduce primary and secondary compilation contexts

NoopCompilation previously served as a AngularCompilation placeholder to satisfy the compilation requirement on AngularCompilationContext in secondary contexts (such as polyfills and server main code), leading to redundant compiler option extraction and tsconfig loading.

AngularCompilationContext is now an abstract base class defining the shared contract. PrimaryCompilationContext encapsulates the active AngularCompilation, manages the lifecycle state, and holds the resolved compiler options. SecondaryCompilationContext omits the compilation entirely, delegates readiness and compiler option resolution to the primary context, and provides no-op lifecycle management. Secondary builds now await primary completion and retrieve compiler options without initializing or invoking a separate compilation.

Author: clydin

packages/angular/build/src/builders/application/execute-build.ts

@@ -8,7 +8,10 @@
 
 import { BuilderContext } from '@angular-devkit/architect';
 import { createAngularCompilation } from '../../tools/angular/compilation';
-import { AngularCompilationContext } from '../../tools/esbuild/angular/compilation-state';
+import {
+  AngularCompilationContext,
+  PrimaryCompilationContext,
+} from '../../tools/esbuild/angular/compilation-state';
 import { SourceFileCache } from '../../tools/esbuild/angular/source-file-cache';
 import { generateBudgetStats } from '../../tools/esbuild/budget-stats';
 import { BundleContextResult, BundlerContext } from '../../tools/esbuild/bundler-context';
@@ -125,7 +128,7 @@ export async function executeBuild(
         !!options.jit,
         !options.serverEntryPoint,
       );
-      angularCompilationContext = new AngularCompilationContext(angularCompilation);
+      angularCompilationContext = new PrimaryCompilationContext(angularCompilation);
       bundlerContexts = setupBundlerContexts(
         options,
         target,

packages/angular/build/src/private.ts

@@ -13,7 +13,8 @@
  * their existence may change in any future version.
  */
 
-import { NoopCompilation, createAngularCompilation } from './tools/angular/compilation';
+import { createAngularCompilation } from './tools/angular/compilation';
+import { SecondaryCompilationContext } from './tools/esbuild/angular/compilation-state';
 import {
   CompilerPluginOptions,
   createCompilerPlugin as internalCreateCompilerPlugin,
@@ -52,7 +53,7 @@ export function createCompilerPlugin(
   return internalCreateCompilerPlugin(
     pluginOptions,
     pluginOptions.noopTypeScriptCompilation
-      ? new NoopCompilation()
+      ? new SecondaryCompilationContext()
       : () => createAngularCompilation(!!pluginOptions.jit, !!pluginOptions.browserOnlyBuild),
     new ComponentStylesheetBundler(
       styleOptions,

packages/angular/build/src/tools/angular/compilation/angular-compilation_spec.ts

@@ -14,7 +14,6 @@ import {
   AngularCompilation,
   AngularCompilationResult,
   DiagnosticModes,
-  NoopCompilation,
   createAngularCompilation,
 } from './index';
 
@@ -59,44 +58,6 @@ describe('AngularCompilation', () => {
     expect(diagnostics).toEqual({});
   });
 
-  describe('NoopCompilation', () => {
-    it('initializes with empty referencedFiles and compiler options', async () => {
-      const compilation = new NoopCompilation();
-      const mockHostOptions = {} as AngularHostOptions;
-      const result = await compilation.initialize('tsconfig.json', mockHostOptions);
-
-      expect(result.referencedFiles).toEqual([]);
-      expect(result.compilerOptions).toBeDefined();
-    });
-
-    it('initializes with CompilerOptionOverrides object', async () => {
-      const compilation = new NoopCompilation();
-      const mockHostOptions = {} as AngularHostOptions;
-      const result = await compilation.initialize('tsconfig.json', mockHostOptions, {
-        sourcemap: true,
-        enableHmr: true,
-      });
-
-      expect(result.referencedFiles).toEqual([]);
-      expect(result.compilerOptions.inlineSources).toBe(true);
-      expect(result.compilerOptions.inlineSourceMap).toBe(true);
-      expect(result.compilerOptions['_enableHmr']).toBe(true);
-    });
-
-    it('throws when calling emitAffectedFiles', () => {
-      const compilation = new NoopCompilation();
-      expect(() => compilation.emitAffectedFiles()).toThrowError(
-        'Not available when using noop compilation.',
-      );
-    });
-
-    it('returns empty diagnostics from diagnoseFiles', async () => {
-      const compilation = new NoopCompilation();
-      const diagnostics = await compilation.diagnoseFiles();
-      expect(diagnostics).toEqual({});
-    });
-  });
-
   describe('TypeScriptCompilation', () => {
     class MockTypeScriptCompilation extends TypeScriptCompilation {
       async initialize(): Promise<AngularCompilationResult> {

packages/angular/build/src/tools/angular/compilation/index.ts

@@ -16,4 +16,3 @@ export {
 } from './angular-compilation';
 export type { CompilerOptionOverrides } from './compiler-options';
 export { createAngularCompilation, type AngularCompilationMode } from './factory';
-export { NoopCompilation } from './noop-compilation';

packages/angular/build/src/tools/angular/compilation/noop-compilation.ts

@@ -6,24 +6,46 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import { type AngularCompilation, NoopCompilation } from '../../angular/compilation';
+import type { CompilerOptions } from '@angular/compiler-cli';
+import type { AngularCompilation } from '../../angular/compilation';
 
-export class AngularCompilationContext {
-  #compilation: AngularCompilation;
+export abstract class AngularCompilationContext {
+  abstract readonly compilation?: AngularCompilation;
+  abstract isPrimary(): this is PrimaryCompilationContext;
+  abstract readonly waitUntilReady: Promise<boolean>;
+  abstract getCompilerOptions(): Promise<CompilerOptions>;
+  abstract dispose(): Promise<void>;
+
+  createSecondaryContext(): AngularCompilationContext {
+    return new SecondaryCompilationContext(this);
+  }
+}
+
+export class PrimaryCompilationContext extends AngularCompilationContext {
+  readonly #compilation: AngularCompilation;
   #pendingCompilation = true;
   #resolveCompilationReady: ((value: boolean) => void) | undefined;
   #compilationReadyPromise: Promise<boolean> | undefined;
   #hasErrors = true;
 
+  #compilerOptions: CompilerOptions | undefined;
+  #resolveCompilerOptions: ((options: CompilerOptions) => void) | undefined;
+  #compilerOptionsPromise: Promise<CompilerOptions> | undefined;
+
   constructor(compilation: AngularCompilation) {
+    super();
     this.#compilation = compilation;
   }
 
-  get compilation(): AngularCompilation {
+  override isPrimary(): this is PrimaryCompilationContext {
+    return true;
+  }
+
+  override get compilation(): AngularCompilation {
     return this.#compilation;
   }
 
-  get waitUntilReady(): Promise<boolean> {
+  override get waitUntilReady(): Promise<boolean> {
     if (!this.#pendingCompilation) {
       return Promise.resolve(this.#hasErrors);
     }
@@ -35,20 +57,51 @@ export class AngularCompilationContext {
     return this.#compilationReadyPromise;
   }
 
+  override getCompilerOptions(): Promise<CompilerOptions> {
+    if (this.#compilerOptions) {
+      return Promise.resolve(this.#compilerOptions);
+    }
+
+    if (!this.#pendingCompilation) {
+      return Promise.resolve({});
+    }
+
+    this.#compilerOptionsPromise ??= new Promise((resolve) => {
+      this.#resolveCompilerOptions = resolve;
+    });
+
+    return this.#compilerOptionsPromise;
+  }
+
+  setCompilerOptions(options: CompilerOptions): void {
+    this.#compilerOptions = options;
+    this.#resolveCompilerOptions?.(options);
+    this.#resolveCompilerOptions = undefined;
+    this.#compilerOptionsPromise = undefined;
+  }
+
   markAsReady(hasErrors: boolean): void {
     this.#hasErrors = hasErrors;
     this.#resolveCompilationReady?.(hasErrors);
+    this.#resolveCompilationReady = undefined;
     this.#compilationReadyPromise = undefined;
     this.#pendingCompilation = false;
+
+    if (this.#resolveCompilerOptions) {
+      this.#resolveCompilerOptions(this.#compilerOptions ?? {});
+      this.#resolveCompilerOptions = undefined;
+      this.#compilerOptionsPromise = undefined;
+    }
   }
 
   markAsInProgress(): void {
     this.#pendingCompilation = true;
+    this.#compilerOptions = undefined;
   }
 
   #disposal: Promise<void> | undefined;
 
-  dispose(): Promise<void> {
+  override dispose(): Promise<void> {
     // Reuse any in progress disposal to ensure all callers can await completion
     return (this.#disposal ??= this.#close());
   }
@@ -61,27 +114,27 @@ export class AngularCompilationContext {
       // Suppress closure errors to avoid unhandled rejections during teardown.
     }
   }
+}
 
-  createSecondaryContext(): AngularCompilationContext {
-    return new SecondaryCompilationContext(this);
+export class SecondaryCompilationContext extends AngularCompilationContext {
+  constructor(private readonly primaryContext?: AngularCompilationContext) {
+    super();
   }
-}
 
-class SecondaryCompilationContext extends AngularCompilationContext {
-  constructor(private primaryContext: AngularCompilationContext) {
-    super(new NoopCompilation());
+  override isPrimary(): this is PrimaryCompilationContext {
+    return false;
   }
 
-  override get waitUntilReady(): Promise<boolean> {
-    return this.primaryContext.waitUntilReady;
+  override get compilation(): undefined {
+    return undefined;
   }
 
-  override markAsReady(hasErrors: boolean): void {
-    // No-op: secondary contexts do not control compilation state
+  override get waitUntilReady(): Promise<boolean> {
+    return this.primaryContext?.waitUntilReady ?? Promise.resolve(false);
   }
 
-  override markAsInProgress(): void {
-    // No-op: secondary contexts do not control compilation state
+  override getCompilerOptions(): Promise<CompilerOptions> {
+    return this.primaryContext?.getCompilerOptions() ?? Promise.resolve({});
   }
 
   override async dispose(): Promise<void> {