fix(@angular/build): aggregate parallel worker performance timings on the main thread

alan-agius4 · alan-agius4 · commit 7040f36e7591 · 2026-06-19T12:07:05.000Z
Rather than having the parallel worker thread print its cumulative durations separately to the console (which causes console spam and disjointed/incomplete final logs), we serialize and return the worker's durations to the main thread upon completing the diagnostics task. The main thread then merges them into the global cumulative durations map, producing a single, complete, and perfectly aggregated performance report at the end of the build.
diff --git a/packages/angular/build/src/tools/angular/compilation/angular-compilation_spec.ts b/packages/angular/build/src/tools/angular/compilation/angular-compilation_spec.ts
@@ -0,0 +1,100 @@
+/**
+ * @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 type * as ng from '@angular/compiler-cli';
+import type { PartialMessage } from 'esbuild';
+import type ts from 'typescript';
+import * as diagnosticsModule from '../../esbuild/angular/diagnostics';
+import * as profilingModule from '../../esbuild/profiling';
+import type { AngularHostOptions } from '../angular-host';
+import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
+
+/**
+ * Minimal stub for the TypeScript module: only DiagnosticCategory is accessed in diagnoseFiles.
+ */
+const MOCK_TYPESCRIPT = {
+  DiagnosticCategory: { Error: 1, Warning: 0, Message: 2, Suggestion: 3 },
+} as unknown as typeof ts;
+
+/** Concrete subclass used to control collectDiagnostics behaviour in tests. */
+class ConcreteCompilation extends AngularCompilation {
+  private diagnostics_: ts.Diagnostic[] = [];
+  private throwError_: Error | undefined;
+
+  setDiagnostics(diagnostics: ts.Diagnostic[]): void {
+    this.diagnostics_ = diagnostics;
+  }
+
+  setThrowError(error: Error): void {
+    this.throwError_ = error;
+  }
+
+  override async initialize(
+    _tsconfig: string,
+    _hostOptions: AngularHostOptions,
+    _compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions,
+  ): Promise<{
+    affectedFiles: ReadonlySet<ts.SourceFile>;
+    compilerOptions: ng.CompilerOptions;
+    referencedFiles: readonly string[];
+  }> {
+    return {
+      affectedFiles: new Set(),
+      compilerOptions: {} as ng.CompilerOptions,
+      referencedFiles: [],
+    };
+  }
+
+  override emitAffectedFiles(): Iterable<EmitFileResult> {
+    return [];
+  }
+
+  protected override *collectDiagnostics(_modes: DiagnosticModes): Iterable<ts.Diagnostic> {
+    if (this.throwError_) {
+      throw this.throwError_;
+    }
+    yield* this.diagnostics_;
+  }
+}
+
+describe('AngularCompilation.diagnoseFiles', () => {
+  let compilation: ConcreteCompilation;
+  let profileAsyncSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    compilation = new ConcreteCompilation();
+    // Default: transparent passthrough so the real loop still runs.
+    profileAsyncSpy = spyOn(profilingModule, 'profileAsync').and.callFake(
+      <T>(_name: string, action: () => Promise<T>): Promise<T> => action(),
+    );
+    spyOn(AngularCompilation, 'loadTypescript').and.resolveTo(MOCK_TYPESCRIPT);
+  });
+
+  it('runs diagnostic collection inside a profileAsync block', async () => {
+    await compilation.diagnoseFiles();
+
+    expect(profileAsyncSpy).toHaveBeenCalledWith('NG_DIAGNOSTICS_TOTAL', jasmine.any(Function));
+  });
+
+  it('returns correct errors and warnings', async () => {
+    const errorDiagnostic = { category: 1 /* Error */ } as ts.Diagnostic;
+    const warningDiagnostic = { category: 0 /* Warning */ } as ts.Diagnostic;
+    compilation.setDiagnostics([errorDiagnostic, warningDiagnostic]);
+
+    spyOn(diagnosticsModule, 'convertTypeScriptDiagnostic').and.callFake(
+      (_ts: typeof ts, diagnostic: ts.Diagnostic): PartialMessage => ({
+        text: diagnostic.category === 1 ? 'error message' : 'warning message',
+      }),
+    );
+
+    const result = await compilation.diagnoseFiles();
+
+    expect(result.errors).toEqual([{ text: 'error message' }]);
+    expect(result.warnings).toEqual([{ text: 'warning message' }]);
+  });
+});
diff --git a/packages/angular/build/src/tools/angular/compilation/parallel-compilation.ts b/packages/angular/build/src/tools/angular/compilation/parallel-compilation.ts
@@ -12,6 +12,7 @@ import { createRequire } from 'node:module';
 import { MessageChannel } from 'node:worker_threads';
 import type { SourceFile } from 'typescript';
 import { WorkerPool } from '../../../utils/worker-pool';
+import { mergeCumulativeDurations } from '../../esbuild/profiling';
 import type { AngularHostOptions } from '../angular-host';
 import { AngularCompilation, DiagnosticModes, EmitFileResult } from './angular-compilation';
 
@@ -124,10 +125,15 @@ export class ParallelCompilation extends AngularCompilation {
     throw new Error('Not implemented in ParallelCompilation.');
   }
 
-  override diagnoseFiles(
+  override async diagnoseFiles(
     modes = DiagnosticModes.All,
   ): Promise<{ errors?: PartialMessage[]; warnings?: PartialMessage[] }> {
-    return this.#worker.run(modes, { name: 'diagnose' });
+    const { timings, ...result } = await this.#worker.run(modes, { name: 'diagnose' });
+    if (timings) {
+      mergeCumulativeDurations(timings);
+    }
+
+    return result;
   }
 
   override emitAffectedFiles(): Promise<Iterable<EmitFileResult>> {
diff --git a/packages/angular/build/src/tools/angular/compilation/parallel-worker.ts b/packages/angular/build/src/tools/angular/compilation/parallel-worker.ts
@@ -11,6 +11,7 @@ import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { type MessagePort, receiveMessageOnPort } from 'node:worker_threads';
 import { SourceFileCache } from '../../esbuild/angular/source-file-cache';
+import { getAndClearCumulativeDurations } from '../../esbuild/profiling';
 import type { AngularCompilation, DiagnosticModes } from './angular-compilation';
 import { AotCompilation } from './aot-compilation';
 import { JitCompilation } from './jit-compilation';
@@ -121,12 +122,17 @@ export async function initialize(request: InitRequest) {
 export async function diagnose(modes: DiagnosticModes): Promise<{
   errors?: PartialMessage[];
   warnings?: PartialMessage[];
+  timings?: Record<string, number[]>;
 }> {
   assert(compilation);
 
   const diagnostics = await compilation.diagnoseFiles(modes);
+  const timings = getAndClearCumulativeDurations();
 
-  return diagnostics;
+  return {
+    ...diagnostics,
+    timings,
+  };
 }
 
 export async function emit() {
diff --git a/packages/angular/build/src/tools/esbuild/profiling.ts b/packages/angular/build/src/tools/esbuild/profiling.ts
@@ -14,6 +14,32 @@ export function resetCumulativeDurations(): void {
   cumulativeDurations?.clear();
 }
 
+export function getAndClearCumulativeDurations(): Record<string, number[]> | undefined {
+  if (!cumulativeDurations || cumulativeDurations.size === 0) {
+    return undefined;
+  }
+
+  const data = Object.fromEntries(cumulativeDurations);
+
+  cumulativeDurations.clear();
+
+  return data;
+}
+
+export function mergeCumulativeDurations(data: Record<string, number[]>): void {
+  cumulativeDurations ??= new Map();
+
+  for (const [name, durations] of Object.entries(data)) {
+    let existing = cumulativeDurations.get(name);
+    if (!existing) {
+      existing = [];
+      cumulativeDurations.set(name, existing);
+    }
+
+    existing.push(...durations);
+  }
+}
+
 export function logCumulativeDurations(): void {
   if (!debugPerformance || !cumulativeDurations) {
     return;
