fix(@angular/build): mark InjectionToken as pure for improved tree-shaking

`new InjectionToken(...)` is not considered pure by default by build tools, which prevents it from being tree-shaken when unused. This can lead to unused services being included in production bundles if they are provided as a default value for a token.

This change marks `new InjectionToken(...)` calls as pure. The `InjectionToken` constructor is side-effect free; its only purpose is to create a token for the dependency injection system. Marking it as pure is safe and  allows build tools like esbuild to tree-shake unused tokens and their dependencies.

Closes #31270

(cherry picked from commit 6556211)

Author: alan-agius4

packages/angular/build/src/tools/babel/plugins/pure-toplevel-functions.ts

@@ -6,12 +6,17 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import type { PluginObj } from '@babel/core';
+import type { NodePath, PluginObj, PluginPass, types } from '@babel/core';
 import annotateAsPure from '@babel/helper-annotate-as-pure';
 import * as tslib from 'tslib';
 
 /**
- * A cached set of TypeScript helper function names used by the helper name matcher utility function.
+ * A set of constructor names that are considered to be side-effect free.
+ */
+const sideEffectFreeConstructors = new Set<string>(['InjectionToken']);
+
+/**
+ * A set of TypeScript helper function names used by the helper name matcher utility function.
  */
 const tslibHelpers = new Set<string>(Object.keys(tslib).filter((h) => h.startsWith('__')));
 
@@ -44,15 +49,23 @@ function isBabelHelperName(name: string): boolean {
   return babelHelpers.has(name);
 }
 
+interface ExtendedPluginPass extends PluginPass {
+  opts: { topLevelSafeMode?: boolean };
+}
+
 /**
  * A babel plugin factory function for adding the PURE annotation to top-level new and call expressions.
- *
  * @returns A babel plugin object instance.
  */
 export default function (): PluginObj {
   return {
     visitor: {
-      CallExpression(path) {
+      CallExpression(path: NodePath<types.CallExpression>, state: ExtendedPluginPass) {
+        const { topLevelSafeMode = false } = state.opts;
+        if (topLevelSafeMode) {
+          return;
+        }
+
         // If the expression has a function parent, it is not top-level
         if (path.getFunctionParent()) {
           return;
@@ -65,6 +78,7 @@ export default function (): PluginObj {
         ) {
           return;
         }
+
         // Do not annotate TypeScript helpers emitted by the TypeScript compiler or Babel helpers.
         // They are intended to cause side effects.
         if (
@@ -76,9 +90,22 @@ export default function (): PluginObj {
 
         annotateAsPure(path);
       },
-      NewExpression(path) {
+      NewExpression(path: NodePath<types.NewExpression>, state: ExtendedPluginPass) {
         // If the expression has a function parent, it is not top-level
-        if (!path.getFunctionParent()) {
+        if (path.getFunctionParent()) {
+          return;
+        }
+
+        const { topLevelSafeMode = false } = state.opts;
+
+        if (!topLevelSafeMode) {
+          annotateAsPure(path);
+
+          return;
+        }
+
+        const callee = path.get('callee');
+        if (callee.isIdentifier() && sideEffectFreeConstructors.has(callee.node.name)) {
           annotateAsPure(path);
         }
       },

packages/angular/build/src/tools/babel/plugins/pure-toplevel-functions_spec.ts

@@ -7,23 +7,24 @@
  */
 
 import { transformSync } from '@babel/core';
-// eslint-disable-next-line import/no-extraneous-dependencies
 import { format } from 'prettier';
 import pureTopLevelPlugin from './pure-toplevel-functions';
 
 function testCase({
   input,
   expected,
+  options,
 }: {
   input: string;
   expected: string;
+  options?: { topLevelSafeMode: boolean };
 }): jasmine.ImplementationCallback {
   return async () => {
     const result = transformSync(input, {
       configFile: false,
       babelrc: false,
       compact: true,
-      plugins: [pureTopLevelPlugin],
+      plugins: [[pureTopLevelPlugin, options]],
     });
     if (!result?.code) {
       fail('Expected babel to return a transform result.');
@@ -152,4 +153,33 @@ describe('pure-toplevel-functions Babel plugin', () => {
       };
     `),
   );
+
+  describe('topLevelSafeMode: true', () => {
+    it(
+      'annotates top-level `new InjectionToken` expressions',
+      testCase({
+        input: `const result = new InjectionToken('abc');`,
+        expected: `const result = /*#__PURE__*/ new InjectionToken('abc');`,
+        options: { topLevelSafeMode: true },
+      }),
+    );
+
+    it(
+      'does not annotate other top-level `new` expressions',
+      testCase({
+        input: 'const result = new SomeClass();',
+        expected: 'const result = new SomeClass();',
+        options: { topLevelSafeMode: true },
+      }),
+    );
+
+    it(
+      'does not annotate top-level function calls',
+      testCase({
+        input: 'const result = someCall();',
+        expected: 'const result = someCall();',
+        options: { topLevelSafeMode: true },
+      }),
+    );
+  });
 });

packages/angular/build/src/tools/esbuild/javascript-transformer-worker.ts

@@ -78,21 +78,19 @@ async function transformWithBabel(
   }
 
   if (options.advancedOptimizations) {
-    const sideEffectFree = options.sideEffects === false;
-    const safeAngularPackage =
-      sideEffectFree && /[\\/]node_modules[\\/]@angular[\\/]/.test(filename);
-
     const { adjustStaticMembers, adjustTypeScriptEnums, elideAngularMetadata, markTopLevelPure } =
       await import('../babel/plugins');
 
-    if (safeAngularPackage) {
-      plugins.push(markTopLevelPure);
-    }
+    const sideEffectFree = options.sideEffects === false;
+    const safeAngularPackage =
+      sideEffectFree && /[\\/]node_modules[\\/]@angular[\\/]/.test(filename);
 
-    plugins.push(elideAngularMetadata, adjustTypeScriptEnums, [
-      adjustStaticMembers,
-      { wrapDecorators: sideEffectFree },
-    ]);
+    plugins.push(
+      [markTopLevelPure, { topLevelSafeMode: !safeAngularPackage }],
+      elideAngularMetadata,
+      adjustTypeScriptEnums,
+      [adjustStaticMembers, { wrapDecorators: sideEffectFree }],
+    );
   }
 
   // If no additional transformations are needed, return the data directly