@angular/core 19.0.0-next.3 → 19.0.0-next.4

package/schematics/bundles/standalone-migration.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.3
+ * @license Angular v19.0.0-next.4
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -11,11 +11,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var schematics = require('@angular-devkit/schematics');
 require('os');
 var ts = require('typescript');
-var compiler_host = require('./compiler_host-bbb5d8fd.js');
+var compiler_host = require('./compiler_host-ca7ba733.js');
 var p = require('path');
 var fs = require('fs');
 var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
-var nodes = require('./nodes-ddfa1613.js');
+var nodes = require('./nodes-0e7d45ca.js');
+var imports = require('./imports-4ac08251.js');
 require('module');
 require('url');
 require('@angular-devkit/core');
@@ -873,7 +874,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new compiler_host.DefinitionMap();
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -891,7 +892,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? compiler_host.literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? compiler_host.literal(null));
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -986,7 +987,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new compiler_host.DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', compiler_host.literal(minVersion));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -1405,7 +1406,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new compiler_host.DefinitionMap();
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -1440,7 +1441,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new compiler_host.DefinitionMap();
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -1491,7 +1492,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new compiler_host.DefinitionMap();
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -1524,7 +1525,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -1575,7 +1576,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new compiler_host.DefinitionMap();
     definitionMap.set('minVersion', compiler_host.literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', compiler_host.literal('19.0.0-next.3'));
+    definitionMap.set('version', compiler_host.literal('19.0.0-next.4'));
     definitionMap.set('ngImport', compiler_host.importExpr(compiler_host.Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -11535,7 +11536,7 @@ class PipeDecoratorHandler {
  * @description
  * Entry point for all public APIs of the compiler-cli package.
  */
-new compiler_host.Version('19.0.0-next.3');
+new compiler_host.Version('19.0.0-next.4');
 
 /**
  * Whether a given decorator should be treated as an Angular decorator.
@@ -13744,7 +13745,7 @@ class DocsExtractor {
      *
      * @param sourceFile The file from which to extract documentable entries.
      */
-    extractAll(sourceFile, rootDir) {
+    extractAll(sourceFile, rootDir, privateModules) {
         const entries = [];
         const symbols = new Map();
         const exportedDeclarations = this.getExportedDeclarations(sourceFile);
@@ -13768,8 +13769,7 @@ class DocsExtractor {
                  */
                 const importedSymbols = getImportedSymbols(realSourceFile);
                 importedSymbols.forEach((moduleName, symbolName) => {
-                    // TODO: we probably want to filter out symbols from private modules (like core/primitives)
-                    if (symbolName.startsWith('ɵ')) {
+                    if (symbolName.startsWith('ɵ') || privateModules.has(moduleName)) {
                         return;
                     }
                     if (symbols.has(symbolName) && symbols.get(symbolName) !== moduleName) {
@@ -18893,7 +18893,7 @@ var semver$1 = /*@__PURE__*/getDefaultExportFromCjs(semver);
  * @param minVersion Minimum required version for the feature.
  */
 function coreVersionSupportsFeature(coreVersion, minVersion) {
-    // A version of `19.0.0-next.3` usually means that core is at head so it supports
+    // A version of `19.0.0-next.4` usually means that core is at head so it supports
     // all features. Use string interpolation prevent the placeholder from being replaced
     // with the current version during build time.
     if (coreVersion === `0.0.0-${'PLACEHOLDER'}`) {
@@ -19364,7 +19364,7 @@ class NgCompiler {
      *
      * @returns A map of symbols with their associated module, eg: ApplicationRef => @angular/core
      */
-    getApiDocumentation(entryPoint) {
+    getApiDocumentation(entryPoint, privateModules) {
         const compilation = this.ensureAnalyzed();
         const checker = this.inputProgram.getTypeChecker();
         const docsExtractor = new DocsExtractor(checker, compilation.metaReader);
@@ -19379,7 +19379,7 @@ class NgCompiler {
         // TODO: Technically the current directory is not the root dir.
         // Should probably be derived from the config.
         const rootDir = this.inputProgram.getCurrentDirectory();
-        return docsExtractor.extractAll(entryPointSourceFile, rootDir);
+        return docsExtractor.extractAll(entryPointSourceFile, rootDir, privateModules);
     }
     /**
      * Collect i18n messages into the `Xi18nContext`.
@@ -20462,8 +20462,8 @@ class NgtscProgram {
      * @param entryPoint Path to the entry point for the package for which API
      *     docs should be extracted.
      */
-    getApiDocumentation(entryPoint) {
-        return this.compiler.getApiDocumentation(entryPoint);
+    getApiDocumentation(entryPoint, privateModules) {
+        return this.compiler.getApiDocumentation(entryPoint, privateModules);
     }
     getEmittedSourceFiles() {
         throw new Error('Method not implemented.');
@@ -20743,6 +20743,20 @@ function isClassReferenceInAngularModule(node, className, moduleName, typeChecke
     });
 }
 
+/** Checks whether a node is referring to a specific import specifier. */
+function isReferenceToImport(typeChecker, node, importSpecifier) {
+    // If this function is called on an identifier (should be most cases), we can quickly rule out
+    // non-matches by comparing the identifier's string and the local name of the import specifier
+    // which saves us some calls to the type checker.
+    if (ts__default["default"].isIdentifier(node) && node.text !== importSpecifier.name.text) {
+        return false;
+    }
+    const nodeSymbol = typeChecker.getTypeAtLocation(node).getSymbol();
+    const importSymbol = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
+    return (!!(nodeSymbol?.declarations?.[0] && importSymbol?.declarations?.[0]) &&
+        nodeSymbol.declarations[0] === importSymbol.declarations[0]);
+}
+
 /*!
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -20750,906 +20764,994 @@ function isClassReferenceInAngularModule(node, className, moduleName, typeChecke
  * 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
  */
-function pruneNgModules(program, host, basePath, rootFileNames, sourceFiles, printer, importRemapper, referenceLookupExcludedFiles) {
-    const filesToRemove = new Set();
-    const tracker = new compiler_host.ChangeTracker(printer, importRemapper);
-    const tsProgram = program.getTsProgram();
-    const typeChecker = tsProgram.getTypeChecker();
-    const referenceResolver = new ReferenceResolver(program, host, rootFileNames, basePath, referenceLookupExcludedFiles);
-    const removalLocations = {
-        arrays: new UniqueItemTracker(),
-        imports: new UniqueItemTracker(),
-        exports: new UniqueItemTracker(),
-        unknown: new Set(),
-    };
-    const classesToRemove = new Set();
-    const barrelExports = new UniqueItemTracker();
-    const nodesToRemove = new Set();
-    sourceFiles.forEach(function walk(node) {
-        if (ts__default["default"].isClassDeclaration(node) && canRemoveClass(node, typeChecker)) {
-            collectRemovalLocations(node, removalLocations, referenceResolver, program);
-            classesToRemove.add(node);
-        }
-        else if (ts__default["default"].isExportDeclaration(node) &&
-            !node.exportClause &&
-            node.moduleSpecifier &&
-            ts__default["default"].isStringLiteralLike(node.moduleSpecifier) &&
-            node.moduleSpecifier.text.startsWith('.')) {
-            const exportedSourceFile = typeChecker
-                .getSymbolAtLocation(node.moduleSpecifier)
-                ?.valueDeclaration?.getSourceFile();
-            if (exportedSourceFile) {
-                barrelExports.track(exportedSourceFile, node);
-            }
-        }
-        node.forEachChild(walk);
-    });
-    // We collect all the places where we need to remove references first before generating the
-    // removal instructions since we may have to remove multiple references from one node.
-    removeArrayReferences(removalLocations.arrays, tracker);
-    removeImportReferences(removalLocations.imports, tracker);
-    removeExportReferences(removalLocations.exports, tracker);
-    addRemovalTodos(removalLocations.unknown, tracker);
-    // Collect all the nodes to be removed before determining which files to delete since we need
-    // to know it ahead of time when deleting barrel files that export other barrel files.
-    (function trackNodesToRemove(nodes) {
-        for (const node of nodes) {
-            const sourceFile = node.getSourceFile();
-            if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodes)) {
-                const barrelExportsForFile = barrelExports.get(sourceFile);
-                nodesToRemove.add(node);
-                filesToRemove.add(sourceFile);
-                barrelExportsForFile && trackNodesToRemove(barrelExportsForFile);
-            }
-            else {
-                nodesToRemove.add(node);
+/**
+ * Converts all declarations in the specified files to standalone.
+ * @param sourceFiles Files that should be migrated.
+ * @param program
+ * @param printer
+ * @param fileImportRemapper Optional function that can be used to remap file-level imports.
+ * @param componentImportRemapper Optional function that can be used to remap component-level
+ * imports.
+ */
+function toStandalone(sourceFiles, program, printer, fileImportRemapper, componentImportRemapper) {
+    const templateTypeChecker = program.compiler.getTemplateTypeChecker();
+    const typeChecker = program.getTsProgram().getTypeChecker();
+    const modulesToMigrate = new Set();
+    const testObjectsToMigrate = new Set();
+    const declarations = new Set();
+    const tracker = new compiler_host.ChangeTracker(printer, fileImportRemapper);
+    for (const sourceFile of sourceFiles) {
+        const modules = findNgModuleClassesToMigrate(sourceFile, typeChecker);
+        const testObjects = findTestObjectsToMigrate(sourceFile, typeChecker);
+        for (const module of modules) {
+            const allModuleDeclarations = extractDeclarationsFromModule(module, templateTypeChecker);
+            const unbootstrappedDeclarations = filterNonBootstrappedDeclarations(allModuleDeclarations, module, templateTypeChecker, typeChecker);
+            if (unbootstrappedDeclarations.length > 0) {
+                modulesToMigrate.add(module);
+                unbootstrappedDeclarations.forEach((decl) => declarations.add(decl));
             }
         }
-    })(classesToRemove);
-    for (const node of nodesToRemove) {
-        const sourceFile = node.getSourceFile();
-        if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodesToRemove)) {
-            filesToRemove.add(sourceFile);
-        }
-        else {
-            tracker.removeNode(node);
-        }
+        testObjects.forEach((obj) => testObjectsToMigrate.add(obj));
     }
-    return { pendingChanges: tracker.recordChanges(), filesToRemove };
+    for (const declaration of declarations) {
+        convertNgModuleDeclarationToStandalone(declaration, declarations, tracker, templateTypeChecker, componentImportRemapper);
+    }
+    for (const node of modulesToMigrate) {
+        migrateNgModuleClass(node, declarations, tracker, typeChecker, templateTypeChecker);
+    }
+    migrateTestDeclarations(testObjectsToMigrate, declarations, tracker, templateTypeChecker, typeChecker);
+    return tracker.recordChanges();
 }
 /**
- * Collects all the nodes that a module needs to be removed from.
- * @param ngModule Module being removed.
- * @param removalLocations
- * @param referenceResolver
- * @param program
+ * Converts a single declaration defined through an NgModule to standalone.
+ * @param decl Declaration being converted.
+ * @param tracker Tracker used to track the file changes.
+ * @param allDeclarations All the declarations that are being converted as a part of this migration.
+ * @param typeChecker
+ * @param importRemapper
  */
-function collectRemovalLocations(ngModule, removalLocations, referenceResolver, program) {
-    const refsByFile = referenceResolver.findReferencesInProject(ngModule.name);
-    const tsProgram = program.getTsProgram();
-    const nodes$1 = new Set();
-    for (const [fileName, refs] of refsByFile) {
-        const sourceFile = tsProgram.getSourceFile(fileName);
-        if (sourceFile) {
-            offsetsToNodes(getNodeLookup(sourceFile), refs, nodes$1);
+function convertNgModuleDeclarationToStandalone(decl, allDeclarations, tracker, typeChecker, importRemapper) {
+    const directiveMeta = typeChecker.getDirectiveMetadata(decl);
+    if (directiveMeta && directiveMeta.decorator && !directiveMeta.isStandalone) {
+        let decorator = addStandaloneToDecorator(directiveMeta.decorator);
+        if (directiveMeta.isComponent) {
+            const importsToAdd = getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper);
+            if (importsToAdd.length > 0) {
+                const hasTrailingComma = importsToAdd.length > 2 &&
+                    !!extractMetadataLiteral(directiveMeta.decorator)?.properties.hasTrailingComma;
+                decorator = addPropertyToAngularDecorator(decorator, ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(
+                // Create a multi-line array when it has a trailing comma.
+                ts__default["default"].factory.createNodeArray(importsToAdd, hasTrailingComma), hasTrailingComma)));
+            }
         }
+        tracker.replaceNode(directiveMeta.decorator, decorator);
     }
-    for (const node of nodes$1) {
-        const closestArray = nodes.closestNode(node, ts__default["default"].isArrayLiteralExpression);
-        if (closestArray) {
-            removalLocations.arrays.track(closestArray, node);
-            continue;
-        }
-        const closestImport = nodes.closestNode(node, ts__default["default"].isNamedImports);
-        if (closestImport) {
-            removalLocations.imports.track(closestImport, node);
-            continue;
-        }
-        const closestExport = nodes.closestNode(node, ts__default["default"].isNamedExports);
-        if (closestExport) {
-            removalLocations.exports.track(closestExport, node);
-            continue;
+    else {
+        const pipeMeta = typeChecker.getPipeMetadata(decl);
+        if (pipeMeta && pipeMeta.decorator && !pipeMeta.isStandalone) {
+            tracker.replaceNode(pipeMeta.decorator, addStandaloneToDecorator(pipeMeta.decorator));
         }
-        removalLocations.unknown.add(node);
     }
 }
 /**
- * Removes all tracked array references.
- * @param locations Locations from which to remove the references.
- * @param tracker Tracker in which to register the changes.
+ * Gets the expressions that should be added to a component's
+ * `imports` array based on its template dependencies.
+ * @param decl Component class declaration.
+ * @param allDeclarations All the declarations that are being converted as a part of this migration.
+ * @param tracker
+ * @param typeChecker
+ * @param importRemapper
  */
-function removeArrayReferences(locations, tracker) {
-    for (const [array, toRemove] of locations.getEntries()) {
-        const newElements = filterRemovedElements(array.elements, toRemove);
-        tracker.replaceNode(array, ts__default["default"].factory.updateArrayLiteralExpression(array, ts__default["default"].factory.createNodeArray(newElements, array.elements.hasTrailingComma)));
+function getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper) {
+    const templateDependencies = findTemplateDependencies(decl, typeChecker);
+    const usedDependenciesInMigration = new Set(templateDependencies.filter((dep) => allDeclarations.has(dep.node)));
+    const seenImports = new Set();
+    const resolvedDependencies = [];
+    for (const dep of templateDependencies) {
+        const importLocation = findImportLocation(dep, decl, usedDependenciesInMigration.has(dep)
+            ? compiler_host.PotentialImportMode.ForceDirect
+            : compiler_host.PotentialImportMode.Normal, typeChecker);
+        if (importLocation && !seenImports.has(importLocation.symbolName)) {
+            seenImports.add(importLocation.symbolName);
+            resolvedDependencies.push(importLocation);
+        }
     }
+    return potentialImportsToExpressions(resolvedDependencies, decl, tracker, importRemapper);
 }
 /**
- * Removes all tracked import references.
- * @param locations Locations from which to remove the references.
- * @param tracker Tracker in which to register the changes.
+ * Converts an array of potential imports to an array of expressions that can be
+ * added to the `imports` array.
+ * @param potentialImports Imports to be converted.
+ * @param component Component class to which the imports will be added.
+ * @param tracker
+ * @param importRemapper
  */
-function removeImportReferences(locations, tracker) {
-    for (const [namedImports, toRemove] of locations.getEntries()) {
-        const newElements = filterRemovedElements(namedImports.elements, toRemove);
-        // If no imports are left, we can try to drop the entire import.
-        if (newElements.length === 0) {
-            const importClause = nodes.closestNode(namedImports, ts__default["default"].isImportClause);
-            // If the import clause has a name we can only drop then named imports.
-            // e.g. `import Foo, {ModuleToRemove} from './foo';` becomes `import Foo from './foo';`.
-            if (importClause && importClause.name) {
-                tracker.replaceNode(importClause, ts__default["default"].factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, undefined));
-            }
-            else {
-                // Otherwise we can drop the entire declaration.
-                const declaration = nodes.closestNode(namedImports, ts__default["default"].isImportDeclaration);
-                if (declaration) {
-                    tracker.removeNode(declaration);
-                }
-            }
+function potentialImportsToExpressions(potentialImports, component, tracker, importRemapper) {
+    const processedDependencies = importRemapper
+        ? importRemapper(potentialImports, component)
+        : potentialImports;
+    return processedDependencies.map((importLocation) => {
+        if (importLocation.moduleSpecifier) {
+            return tracker.addImport(component.getSourceFile(), importLocation.symbolName, importLocation.moduleSpecifier);
         }
-        else {
-            // Otherwise we just drop the imported symbols and keep the declaration intact.
-            tracker.replaceNode(namedImports, ts__default["default"].factory.updateNamedImports(namedImports, newElements));
+        const identifier = ts__default["default"].factory.createIdentifier(importLocation.symbolName);
+        if (!importLocation.isForwardReference) {
+            return identifier;
         }
-    }
+        const forwardRefExpression = tracker.addImport(component.getSourceFile(), 'forwardRef', '@angular/core');
+        const arrowFunction = ts__default["default"].factory.createArrowFunction(undefined, undefined, [], undefined, undefined, identifier);
+        return ts__default["default"].factory.createCallExpression(forwardRefExpression, undefined, [arrowFunction]);
+    });
 }
 /**
- * Removes all tracked export references.
- * @param locations Locations from which to remove the references.
- * @param tracker Tracker in which to register the changes.
+ * Moves all of the declarations of a class decorated with `@NgModule` to its imports.
+ * @param node Class being migrated.
+ * @param allDeclarations All the declarations that are being converted as a part of this migration.
+ * @param tracker
+ * @param typeChecker
+ * @param templateTypeChecker
  */
-function removeExportReferences(locations, tracker) {
-    for (const [namedExports, toRemove] of locations.getEntries()) {
-        const newElements = filterRemovedElements(namedExports.elements, toRemove);
-        // If no exports are left, we can drop the entire declaration.
-        if (newElements.length === 0) {
-            const declaration = nodes.closestNode(namedExports, ts__default["default"].isExportDeclaration);
-            if (declaration) {
-                tracker.removeNode(declaration);
-            }
-        }
-        else {
-            // Otherwise we just drop the exported symbols and keep the declaration intact.
-            tracker.replaceNode(namedExports, ts__default["default"].factory.updateNamedExports(namedExports, newElements));
-        }
+function migrateNgModuleClass(node, allDeclarations, tracker, typeChecker, templateTypeChecker) {
+    const decorator = templateTypeChecker.getNgModuleMetadata(node)?.decorator;
+    const metadata = decorator ? extractMetadataLiteral(decorator) : null;
+    if (metadata) {
+        moveDeclarationsToImports(metadata, allDeclarations, typeChecker, templateTypeChecker, tracker);
     }
 }
 /**
- * Determines whether an `@NgModule` class is safe to remove. A module is safe to remove if:
- * 1. It has no `declarations`.
- * 2. It has no `providers`.
- * 3. It has no `bootstrap` components.
- * 4. It has no `ModuleWithProviders` in its `imports`.
- * 5. It has no class members. Empty construstors are ignored.
- * @param node Class that is being checked.
+ * Moves all the symbol references from the `declarations` array to the `imports`
+ * array of an `NgModule` class and removes the `declarations`.
+ * @param literal Object literal used to configure the module that should be migrated.
+ * @param allDeclarations All the declarations that are being converted as a part of this migration.
  * @param typeChecker
+ * @param tracker
  */
-function canRemoveClass(node, typeChecker) {
-    const decorator = findNgModuleDecorator(node, typeChecker)?.node;
-    // We can't remove a declaration if it's not a valid `NgModule`.
-    if (!decorator || !ts__default["default"].isCallExpression(decorator.expression)) {
-        return false;
-    }
-    // Unsupported case, e.g. `@NgModule(SOME_VALUE)`.
-    if (decorator.expression.arguments.length > 0 &&
-        !ts__default["default"].isObjectLiteralExpression(decorator.expression.arguments[0])) {
-        return false;
-    }
-    // We can't remove modules that have class members. We make an exception for an
-    // empty constructor which may have been generated by a tool and forgotten.
-    if (node.members.length > 0 && node.members.some((member) => !isEmptyConstructor(member))) {
-        return false;
-    }
-    // An empty `NgModule` call can be removed.
-    if (decorator.expression.arguments.length === 0) {
-        return true;
+function moveDeclarationsToImports(literal, allDeclarations, typeChecker, templateTypeChecker, tracker) {
+    const declarationsProp = findLiteralProperty(literal, 'declarations');
+    if (!declarationsProp) {
+        return;
     }
-    const literal = decorator.expression.arguments[0];
-    const imports = findLiteralProperty(literal, 'imports');
-    if (imports && isNonEmptyNgModuleProperty(imports)) {
-        // We can't remove the class if at least one import isn't identifier, because it may be a
-        // `ModuleWithProviders` which is the equivalent of having something in the `providers` array.
-        for (const dep of imports.initializer.elements) {
-            if (!ts__default["default"].isIdentifier(dep)) {
-                return false;
-            }
-            const depDeclaration = findClassDeclaration(dep, typeChecker);
-            const depNgModule = depDeclaration
-                ? findNgModuleDecorator(depDeclaration, typeChecker)
-                : null;
-            // If any of the dependencies of the class is an `NgModule` that can't be removed, the class
-            // itself can't be removed either, because it may be part of a transitive dependency chain.
-            if (depDeclaration !== null &&
-                depNgModule !== null &&
-                !canRemoveClass(depDeclaration, typeChecker)) {
-                return false;
+    const declarationsToPreserve = [];
+    const declarationsToCopy = [];
+    const properties = [];
+    const importsProp = findLiteralProperty(literal, 'imports');
+    const hasAnyArrayTrailingComma = literal.properties.some((prop) => ts__default["default"].isPropertyAssignment(prop) &&
+        ts__default["default"].isArrayLiteralExpression(prop.initializer) &&
+        prop.initializer.elements.hasTrailingComma);
+    // Separate the declarations that we want to keep and ones we need to copy into the `imports`.
+    if (ts__default["default"].isPropertyAssignment(declarationsProp)) {
+        // If the declarations are an array, we can analyze it to
+        // find any classes from the current migration.
+        if (ts__default["default"].isArrayLiteralExpression(declarationsProp.initializer)) {
+            for (const el of declarationsProp.initializer.elements) {
+                if (ts__default["default"].isIdentifier(el)) {
+                    const correspondingClass = findClassDeclaration(el, typeChecker);
+                    if (!correspondingClass ||
+                        // Check whether the declaration is either standalone already or is being converted
+                        // in this migration. We need to check if it's standalone already, in order to correct
+                        // some cases where the main app and the test files are being migrated in separate
+                        // programs.
+                        isStandaloneDeclaration(correspondingClass, allDeclarations, templateTypeChecker)) {
+                        declarationsToCopy.push(el);
+                    }
+                    else {
+                        declarationsToPreserve.push(el);
+                    }
+                }
+                else {
+                    declarationsToCopy.push(el);
+                }
             }
         }
+        else {
+            // Otherwise create a spread that will be copied into the `imports`.
+            declarationsToCopy.push(ts__default["default"].factory.createSpreadElement(declarationsProp.initializer));
+        }
+    }
+    // If there are no `imports`, create them with the declarations we want to copy.
+    if (!importsProp && declarationsToCopy.length > 0) {
+        properties.push(ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray(declarationsToCopy, hasAnyArrayTrailingComma && declarationsToCopy.length > 2))));
     }
-    // We can't remove classes that have any `declarations`, `providers` or `bootstrap` elements.
-    // Also err on the side of caution and don't remove modules where any of the aforementioned
-    // properties aren't initialized to an array literal.
     for (const prop of literal.properties) {
-        if (isNonEmptyNgModuleProperty(prop) &&
-            (prop.name.text === 'declarations' ||
-                prop.name.text === 'providers' ||
-                prop.name.text === 'bootstrap')) {
-            return false;
+        if (!isNamedPropertyAssignment(prop)) {
+            properties.push(prop);
+            continue;
+        }
+        // If we have declarations to preserve, update the existing property, otherwise drop it.
+        if (prop === declarationsProp) {
+            if (declarationsToPreserve.length > 0) {
+                const hasTrailingComma = ts__default["default"].isArrayLiteralExpression(prop.initializer)
+                    ? prop.initializer.elements.hasTrailingComma
+                    : hasAnyArrayTrailingComma;
+                properties.push(ts__default["default"].factory.updatePropertyAssignment(prop, prop.name, ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray(declarationsToPreserve, hasTrailingComma && declarationsToPreserve.length > 2))));
+            }
+            continue;
+        }
+        // If we have an `imports` array and declarations
+        // that should be copied, we merge the two arrays.
+        if (prop === importsProp && declarationsToCopy.length > 0) {
+            let initializer;
+            if (ts__default["default"].isArrayLiteralExpression(prop.initializer)) {
+                initializer = ts__default["default"].factory.updateArrayLiteralExpression(prop.initializer, ts__default["default"].factory.createNodeArray([...prop.initializer.elements, ...declarationsToCopy], prop.initializer.elements.hasTrailingComma));
+            }
+            else {
+                initializer = ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray([ts__default["default"].factory.createSpreadElement(prop.initializer), ...declarationsToCopy], 
+                // Expect the declarations to be greater than 1 since
+                // we have the pre-existing initializer already.
+                hasAnyArrayTrailingComma && declarationsToCopy.length > 1));
+            }
+            properties.push(ts__default["default"].factory.updatePropertyAssignment(prop, prop.name, initializer));
+            continue;
         }
+        // Retain any remaining properties.
+        properties.push(prop);
     }
-    return true;
+    tracker.replaceNode(literal, ts__default["default"].factory.updateObjectLiteralExpression(literal, ts__default["default"].factory.createNodeArray(properties, literal.properties.hasTrailingComma)), ts__default["default"].EmitHint.Expression);
+}
+/** Adds `standalone: true` to a decorator node. */
+function addStandaloneToDecorator(node) {
+    return addPropertyToAngularDecorator(node, ts__default["default"].factory.createPropertyAssignment('standalone', ts__default["default"].factory.createToken(ts__default["default"].SyntaxKind.TrueKeyword)));
 }
 /**
- * Checks whether a node is a non-empty property from an NgModule's metadata. This is defined as a
- * property assignment with a static name, initialized to an array literal with more than one
- * element.
- * @param node Node to be checked.
+ * Adds a property to an Angular decorator node.
+ * @param node Decorator to which to add the property.
+ * @param property Property to add.
  */
-function isNonEmptyNgModuleProperty(node) {
-    return (ts__default["default"].isPropertyAssignment(node) &&
-        ts__default["default"].isIdentifier(node.name) &&
-        ts__default["default"].isArrayLiteralExpression(node.initializer) &&
-        node.initializer.elements.length > 0);
+function addPropertyToAngularDecorator(node, property) {
+    // Invalid decorator.
+    if (!ts__default["default"].isCallExpression(node.expression) || node.expression.arguments.length > 1) {
+        return node;
+    }
+    let literalProperties;
+    let hasTrailingComma = false;
+    if (node.expression.arguments.length === 0) {
+        literalProperties = [property];
+    }
+    else if (ts__default["default"].isObjectLiteralExpression(node.expression.arguments[0])) {
+        hasTrailingComma = node.expression.arguments[0].properties.hasTrailingComma;
+        literalProperties = [...node.expression.arguments[0].properties, property];
+    }
+    else {
+        // Unsupported case (e.g. `@Component(SOME_CONST)`). Return the original node.
+        return node;
+    }
+    // Use `createDecorator` instead of `updateDecorator`, because
+    // the latter ends up duplicating the node's leading comment.
+    return ts__default["default"].factory.createDecorator(ts__default["default"].factory.createCallExpression(node.expression.expression, node.expression.typeArguments, [
+        ts__default["default"].factory.createObjectLiteralExpression(ts__default["default"].factory.createNodeArray(literalProperties, hasTrailingComma), literalProperties.length > 1),
+    ]));
+}
+/** Checks if a node is a `PropertyAssignment` with a name. */
+function isNamedPropertyAssignment(node) {
+    return ts__default["default"].isPropertyAssignment(node) && node.name && ts__default["default"].isIdentifier(node.name);
 }
 /**
- * Determines if a file is safe to delete. A file is safe to delete if all it contains are
- * import statements, class declarations that are about to be deleted and non-exported code.
- * @param sourceFile File that is being checked.
- * @param nodesToBeRemoved Nodes that are being removed as a part of the migration.
+ * Finds the import from which to bring in a template dependency of a component.
+ * @param target Dependency that we're searching for.
+ * @param inComponent Component in which the dependency is used.
+ * @param importMode Mode in which to resolve the import target.
+ * @param typeChecker
  */
-function canRemoveFile(sourceFile, nodesToBeRemoved) {
-    for (const node of sourceFile.statements) {
-        if (ts__default["default"].isImportDeclaration(node) || nodesToBeRemoved.has(node)) {
-            continue;
+function findImportLocation(target, inComponent, importMode, typeChecker) {
+    const importLocations = typeChecker.getPotentialImportsFor(target, inComponent, importMode);
+    let firstSameFileImport = null;
+    let firstModuleImport = null;
+    for (const location of importLocations) {
+        // Prefer a standalone import, if we can find one.
+        // Otherwise fall back to the first module-based import.
+        if (location.kind === compiler_host.PotentialImportKind.Standalone) {
+            return location;
         }
-        if (ts__default["default"].isExportDeclaration(node) ||
-            (ts__default["default"].canHaveModifiers(node) &&
-                ts__default["default"].getModifiers(node)?.some((m) => m.kind === ts__default["default"].SyntaxKind.ExportKeyword))) {
-            return false;
+        if (!location.moduleSpecifier && !firstSameFileImport) {
+            firstSameFileImport = location;
+        }
+        if (location.kind === compiler_host.PotentialImportKind.NgModule &&
+            !firstModuleImport &&
+            // ɵ is used for some internal Angular modules that we want to skip over.
+            !location.symbolName.startsWith('ɵ')) {
+            firstModuleImport = location;
         }
     }
-    return true;
+    return firstSameFileImport || firstModuleImport || importLocations[0] || null;
 }
 /**
- * Gets whether an AST node contains another AST node.
- * @param parent Parent node that may contain the child.
- * @param child Child node that is being checked.
+ * Checks whether a node is an `NgModule` metadata element with at least one element.
+ * E.g. `declarations: [Foo]` or `declarations: SOME_VAR` would match this description,
+ * but not `declarations: []`.
  */
-function contains(parent, child) {
-    return (parent === child ||
-        (parent.getSourceFile().fileName === child.getSourceFile().fileName &&
-            child.getStart() >= parent.getStart() &&
-            child.getStart() <= parent.getEnd()));
+function hasNgModuleMetadataElements(node) {
+    return (ts__default["default"].isPropertyAssignment(node) &&
+        (!ts__default["default"].isArrayLiteralExpression(node.initializer) || node.initializer.elements.length > 0));
 }
-/**
- * Removes AST nodes from a node array.
- * @param elements Array from which to remove the nodes.
- * @param toRemove Nodes that should be removed.
- */
-function filterRemovedElements(elements, toRemove) {
-    return elements.filter((el) => {
-        for (const node of toRemove) {
-            // Check that the element contains the node, despite knowing with relative certainty that it
-            // does, because this allows us to unwrap some nodes. E.g. if we have `[((toRemove))]`, we
-            // want to remove the entire parenthesized expression, rather than just `toRemove`.
-            if (contains(el, node)) {
-                return false;
+/** Finds all modules whose declarations can be migrated. */
+function findNgModuleClassesToMigrate(sourceFile, typeChecker) {
+    const modules = [];
+    if (imports.getImportSpecifier(sourceFile, '@angular/core', 'NgModule')) {
+        sourceFile.forEachChild(function walk(node) {
+            if (ts__default["default"].isClassDeclaration(node)) {
+                const decorator = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(node) || []).find((current) => current.name === 'NgModule');
+                const metadata = decorator ? extractMetadataLiteral(decorator.node) : null;
+                if (metadata) {
+                    const declarations = findLiteralProperty(metadata, 'declarations');
+                    if (declarations != null && hasNgModuleMetadataElements(declarations)) {
+                        modules.push(node);
+                    }
+                }
             }
-        }
-        return true;
-    });
+            node.forEachChild(walk);
+        });
+    }
+    return modules;
 }
-/** Returns whether a node as an empty constructor. */
-function isEmptyConstructor(node) {
-    return (ts__default["default"].isConstructorDeclaration(node) &&
-        node.parameters.length === 0 &&
-        (node.body == null || node.body.statements.length === 0));
+/** Finds all testing object literals that need to be migrated. */
+function findTestObjectsToMigrate(sourceFile, typeChecker) {
+    const testObjects = [];
+    const testBedImport = imports.getImportSpecifier(sourceFile, '@angular/core/testing', 'TestBed');
+    const catalystImport = imports.getImportSpecifier(sourceFile, /testing\/catalyst$/, 'setupModule');
+    if (testBedImport || catalystImport) {
+        sourceFile.forEachChild(function walk(node) {
+            const isObjectLiteralCall = ts__default["default"].isCallExpression(node) &&
+                node.arguments.length > 0 &&
+                // `arguments[0]` is the testing module config.
+                ts__default["default"].isObjectLiteralExpression(node.arguments[0]);
+            const config = isObjectLiteralCall ? node.arguments[0] : null;
+            const isTestBedCall = isObjectLiteralCall &&
+                testBedImport &&
+                ts__default["default"].isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === 'configureTestingModule' &&
+                isReferenceToImport(typeChecker, node.expression.expression, testBedImport);
+            const isCatalystCall = isObjectLiteralCall &&
+                catalystImport &&
+                ts__default["default"].isIdentifier(node.expression) &&
+                isReferenceToImport(typeChecker, node.expression, catalystImport);
+            if ((isTestBedCall || isCatalystCall) && config) {
+                const declarations = findLiteralProperty(config, 'declarations');
+                if (declarations &&
+                    ts__default["default"].isPropertyAssignment(declarations) &&
+                    ts__default["default"].isArrayLiteralExpression(declarations.initializer) &&
+                    declarations.initializer.elements.length > 0) {
+                    testObjects.push(config);
+                }
+            }
+            node.forEachChild(walk);
+        });
+    }
+    return testObjects;
 }
 /**
- * Adds TODO comments to nodes that couldn't be removed manually.
- * @param nodes Nodes to which to add the TODO.
- * @param tracker Tracker in which to register the changes.
+ * Finds the classes corresponding to dependencies used in a component's template.
+ * @param decl Component in whose template we're looking for dependencies.
+ * @param typeChecker
  */
-function addRemovalTodos(nodes, tracker) {
-    for (const node of nodes) {
-        // Note: the comment is inserted using string manipulation, instead of going through the AST,
-        // because this way we preserve more of the app's original formatting.
-        // Note: in theory this can duplicate comments if the module pruning runs multiple times on
-        // the same node. In practice it is unlikely, because the second time the node won't be picked
-        // up by the language service as a reference, because the class won't exist anymore.
-        tracker.insertText(node.getSourceFile(), node.getFullStart(), ` /* TODO(standalone-migration): clean up removed NgModule reference manually. */ `);
+function findTemplateDependencies(decl, typeChecker) {
+    const results = [];
+    const usedDirectives = typeChecker.getUsedDirectives(decl);
+    const usedPipes = typeChecker.getUsedPipes(decl);
+    if (usedDirectives !== null) {
+        for (const dir of usedDirectives) {
+            if (ts__default["default"].isClassDeclaration(dir.ref.node)) {
+                results.push(dir.ref);
+            }
+        }
     }
-}
-/** Finds the `NgModule` decorator in a class, if it exists. */
-function findNgModuleDecorator(node, typeChecker) {
-    const decorators = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(node) || []);
-    return decorators.find((decorator) => decorator.name === 'NgModule') || null;
-}
-
-/** Checks whether a node is referring to a specific import specifier. */
-function isReferenceToImport(typeChecker, node, importSpecifier) {
-    // If this function is called on an identifier (should be most cases), we can quickly rule out
-    // non-matches by comparing the identifier's string and the local name of the import specifier
-    // which saves us some calls to the type checker.
-    if (ts__default["default"].isIdentifier(node) && node.text !== importSpecifier.name.text) {
-        return false;
+    if (usedPipes !== null) {
+        const potentialPipes = typeChecker.getPotentialPipes(decl);
+        for (const pipe of potentialPipes) {
+            if (ts__default["default"].isClassDeclaration(pipe.ref.node) &&
+                usedPipes.some((current) => pipe.name === current)) {
+                results.push(pipe.ref);
+            }
+        }
     }
-    const nodeSymbol = typeChecker.getTypeAtLocation(node).getSymbol();
-    const importSymbol = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
-    return (!!(nodeSymbol?.declarations?.[0] && importSymbol?.declarations?.[0]) &&
-        nodeSymbol.declarations[0] === importSymbol.declarations[0]);
+    return results;
 }
-
-/*!
- * @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
- */
 /**
- * Converts all declarations in the specified files to standalone.
- * @param sourceFiles Files that should be migrated.
- * @param program
- * @param printer
- * @param fileImportRemapper Optional function that can be used to remap file-level imports.
- * @param componentImportRemapper Optional function that can be used to remap component-level
- * imports.
+ * Removes any declarations that are a part of a module's `bootstrap`
+ * array from an array of declarations.
+ * @param declarations Anaalyzed declarations of the module.
+ * @param ngModule Module whote declarations are being filtered.
+ * @param templateTypeChecker
+ * @param typeChecker
  */
-function toStandalone(sourceFiles, program, printer, fileImportRemapper, componentImportRemapper) {
-    const templateTypeChecker = program.compiler.getTemplateTypeChecker();
-    const typeChecker = program.getTsProgram().getTypeChecker();
-    const modulesToMigrate = new Set();
-    const testObjectsToMigrate = new Set();
-    const declarations = new Set();
-    const tracker = new compiler_host.ChangeTracker(printer, fileImportRemapper);
-    for (const sourceFile of sourceFiles) {
-        const modules = findNgModuleClassesToMigrate(sourceFile, typeChecker);
-        const testObjects = findTestObjectsToMigrate(sourceFile, typeChecker);
-        for (const module of modules) {
-            const allModuleDeclarations = extractDeclarationsFromModule(module, templateTypeChecker);
-            const unbootstrappedDeclarations = filterNonBootstrappedDeclarations(allModuleDeclarations, module, templateTypeChecker, typeChecker);
-            if (unbootstrappedDeclarations.length > 0) {
-                modulesToMigrate.add(module);
-                unbootstrappedDeclarations.forEach((decl) => declarations.add(decl));
-            }
-        }
-        testObjects.forEach((obj) => testObjectsToMigrate.add(obj));
+function filterNonBootstrappedDeclarations(declarations, ngModule, templateTypeChecker, typeChecker) {
+    const metadata = templateTypeChecker.getNgModuleMetadata(ngModule);
+    const metaLiteral = metadata && metadata.decorator ? extractMetadataLiteral(metadata.decorator) : null;
+    const bootstrapProp = metaLiteral ? findLiteralProperty(metaLiteral, 'bootstrap') : null;
+    // If there's no `bootstrap`, we can't filter.
+    if (!bootstrapProp) {
+        return declarations;
     }
-    for (const declaration of declarations) {
-        convertNgModuleDeclarationToStandalone(declaration, declarations, tracker, templateTypeChecker, componentImportRemapper);
+    // If we can't analyze the `bootstrap` property, we can't safely determine which
+    // declarations aren't bootstrapped so we assume that all of them are.
+    if (!ts__default["default"].isPropertyAssignment(bootstrapProp) ||
+        !ts__default["default"].isArrayLiteralExpression(bootstrapProp.initializer)) {
+        return [];
     }
-    for (const node of modulesToMigrate) {
-        migrateNgModuleClass(node, declarations, tracker, typeChecker, templateTypeChecker);
+    const bootstrappedClasses = new Set();
+    for (const el of bootstrapProp.initializer.elements) {
+        const referencedClass = ts__default["default"].isIdentifier(el) ? findClassDeclaration(el, typeChecker) : null;
+        // If we can resolve an element to a class, we can filter it out,
+        // otherwise assume that the array isn't static.
+        if (referencedClass) {
+            bootstrappedClasses.add(referencedClass);
+        }
+        else {
+            return [];
+        }
     }
-    migrateTestDeclarations(testObjectsToMigrate, declarations, tracker, templateTypeChecker, typeChecker);
-    return tracker.recordChanges();
+    return declarations.filter((ref) => !bootstrappedClasses.has(ref));
 }
 /**
- * Converts a single declaration defined through an NgModule to standalone.
- * @param decl Declaration being converted.
- * @param tracker Tracker used to track the file changes.
- * @param allDeclarations All the declarations that are being converted as a part of this migration.
+ * Extracts all classes that are referenced in a module's `declarations` array.
+ * @param ngModule Module whose declarations are being extraced.
+ * @param templateTypeChecker
+ */
+function extractDeclarationsFromModule(ngModule, templateTypeChecker) {
+    const metadata = templateTypeChecker.getNgModuleMetadata(ngModule);
+    return metadata
+        ? metadata.declarations
+            .filter((decl) => ts__default["default"].isClassDeclaration(decl.node))
+            .map((decl) => decl.node)
+        : [];
+}
+/**
+ * Migrates the `declarations` from a unit test file to standalone.
+ * @param testObjects Object literals used to configure the testing modules.
+ * @param declarationsOutsideOfTestFiles Non-testing declarations that are part of this migration.
+ * @param tracker
+ * @param templateTypeChecker
  * @param typeChecker
- * @param importRemapper
  */
-function convertNgModuleDeclarationToStandalone(decl, allDeclarations, tracker, typeChecker, importRemapper) {
-    const directiveMeta = typeChecker.getDirectiveMetadata(decl);
-    if (directiveMeta && directiveMeta.decorator && !directiveMeta.isStandalone) {
-        let decorator = addStandaloneToDecorator(directiveMeta.decorator);
-        if (directiveMeta.isComponent) {
-            const importsToAdd = getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper);
-            if (importsToAdd.length > 0) {
-                const hasTrailingComma = importsToAdd.length > 2 &&
-                    !!extractMetadataLiteral(directiveMeta.decorator)?.properties.hasTrailingComma;
-                decorator = addPropertyToAngularDecorator(decorator, ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(
-                // Create a multi-line array when it has a trailing comma.
-                ts__default["default"].factory.createNodeArray(importsToAdd, hasTrailingComma), hasTrailingComma)));
+function migrateTestDeclarations(testObjects, declarationsOutsideOfTestFiles, tracker, templateTypeChecker, typeChecker) {
+    const { decorators, componentImports } = analyzeTestingModules(testObjects, typeChecker);
+    const allDeclarations = new Set(declarationsOutsideOfTestFiles);
+    for (const decorator of decorators) {
+        const closestClass = nodes.closestNode(decorator.node, ts__default["default"].isClassDeclaration);
+        if (decorator.name === 'Pipe' || decorator.name === 'Directive') {
+            tracker.replaceNode(decorator.node, addStandaloneToDecorator(decorator.node));
+            if (closestClass) {
+                allDeclarations.add(closestClass);
             }
         }
-        tracker.replaceNode(directiveMeta.decorator, decorator);
-    }
-    else {
-        const pipeMeta = typeChecker.getPipeMetadata(decl);
-        if (pipeMeta && pipeMeta.decorator && !pipeMeta.isStandalone) {
-            tracker.replaceNode(pipeMeta.decorator, addStandaloneToDecorator(pipeMeta.decorator));
+        else if (decorator.name === 'Component') {
+            const newDecorator = addStandaloneToDecorator(decorator.node);
+            const importsToAdd = componentImports.get(decorator.node);
+            if (closestClass) {
+                allDeclarations.add(closestClass);
+            }
+            if (importsToAdd && importsToAdd.size > 0) {
+                const hasTrailingComma = importsToAdd.size > 2 &&
+                    !!extractMetadataLiteral(decorator.node)?.properties.hasTrailingComma;
+                const importsArray = ts__default["default"].factory.createNodeArray(Array.from(importsToAdd), hasTrailingComma);
+                tracker.replaceNode(decorator.node, addPropertyToAngularDecorator(newDecorator, ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(importsArray))));
+            }
+            else {
+                tracker.replaceNode(decorator.node, newDecorator);
+            }
         }
     }
+    for (const obj of testObjects) {
+        moveDeclarationsToImports(obj, allDeclarations, typeChecker, templateTypeChecker, tracker);
+    }
 }
 /**
- * Gets the expressions that should be added to a component's
- * `imports` array based on its template dependencies.
- * @param decl Component class declaration.
- * @param allDeclarations All the declarations that are being converted as a part of this migration.
- * @param tracker
- * @param typeChecker
- * @param importRemapper
+ * Analyzes a set of objects used to configure testing modules and returns the AST
+ * nodes that need to be migrated and the imports that should be added to the imports
+ * of any declared components.
+ * @param testObjects Object literals that should be analyzed.
  */
-function getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper) {
-    const templateDependencies = findTemplateDependencies(decl, typeChecker);
-    const usedDependenciesInMigration = new Set(templateDependencies.filter((dep) => allDeclarations.has(dep.node)));
-    const imports = [];
-    const seenImports = new Set();
-    const resolvedDependencies = [];
-    for (const dep of templateDependencies) {
-        const importLocation = findImportLocation(dep, decl, usedDependenciesInMigration.has(dep)
-            ? compiler_host.PotentialImportMode.ForceDirect
-            : compiler_host.PotentialImportMode.Normal, typeChecker);
-        if (importLocation && !seenImports.has(importLocation.symbolName)) {
-            seenImports.add(importLocation.symbolName);
-            resolvedDependencies.push(importLocation);
-        }
-    }
-    const processedDependencies = importRemapper
-        ? importRemapper(resolvedDependencies, decl)
-        : resolvedDependencies;
-    for (const importLocation of processedDependencies) {
-        if (importLocation.moduleSpecifier) {
-            const identifier = tracker.addImport(decl.getSourceFile(), importLocation.symbolName, importLocation.moduleSpecifier);
-            imports.push(identifier);
+function analyzeTestingModules(testObjects, typeChecker) {
+    const seenDeclarations = new Set();
+    const decorators = [];
+    const componentImports = new Map();
+    for (const obj of testObjects) {
+        const declarations = extractDeclarationsFromTestObject(obj, typeChecker);
+        if (declarations.length === 0) {
+            continue;
         }
-        else {
-            const identifier = ts__default["default"].factory.createIdentifier(importLocation.symbolName);
-            if (importLocation.isForwardReference) {
-                const forwardRefExpression = tracker.addImport(decl.getSourceFile(), 'forwardRef', '@angular/core');
-                const arrowFunction = ts__default["default"].factory.createArrowFunction(undefined, undefined, [], undefined, undefined, identifier);
-                imports.push(ts__default["default"].factory.createCallExpression(forwardRefExpression, undefined, [arrowFunction]));
+        const importsProp = findLiteralProperty(obj, 'imports');
+        const importElements = importsProp &&
+            hasNgModuleMetadataElements(importsProp) &&
+            ts__default["default"].isArrayLiteralExpression(importsProp.initializer)
+            ? importsProp.initializer.elements.filter((el) => {
+                // Filter out calls since they may be a `ModuleWithProviders`.
+                return (!ts__default["default"].isCallExpression(el) &&
+                    // Also filter out the animations modules since they throw errors if they're imported
+                    // multiple times and it's common for apps to use the `NoopAnimationsModule` to
+                    // disable animations in screenshot tests.
+                    !isClassReferenceInAngularModule(el, /^BrowserAnimationsModule|NoopAnimationsModule$/, 'platform-browser/animations', typeChecker));
+            })
+            : null;
+        for (const decl of declarations) {
+            if (seenDeclarations.has(decl)) {
+                continue;
             }
-            else {
-                imports.push(identifier);
+            const [decorator] = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(decl) || []);
+            if (decorator) {
+                seenDeclarations.add(decl);
+                decorators.push(decorator);
+                if (decorator.name === 'Component' && importElements) {
+                    // We try to de-duplicate the imports being added to a component, because it may be
+                    // declared in different testing modules with a different set of imports.
+                    let imports = componentImports.get(decorator.node);
+                    if (!imports) {
+                        imports = new Set();
+                        componentImports.set(decorator.node, imports);
+                    }
+                    importElements.forEach((imp) => imports.add(imp));
+                }
             }
         }
     }
-    return imports;
+    return { decorators, componentImports };
 }
 /**
- * Moves all of the declarations of a class decorated with `@NgModule` to its imports.
- * @param node Class being migrated.
- * @param allDeclarations All the declarations that are being converted as a part of this migration.
- * @param tracker
+ * Finds the class declarations that are being referred
+ * to in the `declarations` of an object literal.
+ * @param obj Object literal that may contain the declarations.
  * @param typeChecker
- * @param templateTypeChecker
  */
-function migrateNgModuleClass(node, allDeclarations, tracker, typeChecker, templateTypeChecker) {
-    const decorator = templateTypeChecker.getNgModuleMetadata(node)?.decorator;
-    const metadata = decorator ? extractMetadataLiteral(decorator) : null;
-    if (metadata) {
-        moveDeclarationsToImports(metadata, allDeclarations, typeChecker, templateTypeChecker, tracker);
+function extractDeclarationsFromTestObject(obj, typeChecker) {
+    const results = [];
+    const declarations = findLiteralProperty(obj, 'declarations');
+    if (declarations &&
+        hasNgModuleMetadataElements(declarations) &&
+        ts__default["default"].isArrayLiteralExpression(declarations.initializer)) {
+        for (const element of declarations.initializer.elements) {
+            const declaration = findClassDeclaration(element, typeChecker);
+            // Note that we only migrate classes that are in the same file as the testing module,
+            // because external fixture components are somewhat rare and handling them is going
+            // to involve a lot of assumptions that are likely to be incorrect.
+            if (declaration && declaration.getSourceFile().fileName === obj.getSourceFile().fileName) {
+                results.push(declaration);
+            }
+        }
     }
+    return results;
+}
+/** Extracts the metadata object literal from an Angular decorator. */
+function extractMetadataLiteral(decorator) {
+    // `arguments[0]` is the metadata object literal.
+    return ts__default["default"].isCallExpression(decorator.expression) &&
+        decorator.expression.arguments.length === 1 &&
+        ts__default["default"].isObjectLiteralExpression(decorator.expression.arguments[0])
+        ? decorator.expression.arguments[0]
+        : null;
 }
 /**
- * Moves all the symbol references from the `declarations` array to the `imports`
- * array of an `NgModule` class and removes the `declarations`.
- * @param literal Object literal used to configure the module that should be migrated.
- * @param allDeclarations All the declarations that are being converted as a part of this migration.
- * @param typeChecker
- * @param tracker
+ * Checks whether a class is a standalone declaration.
+ * @param node Class being checked.
+ * @param declarationsInMigration Classes that are being converted to standalone in this migration.
+ * @param templateTypeChecker
  */
-function moveDeclarationsToImports(literal, allDeclarations, typeChecker, templateTypeChecker, tracker) {
-    const declarationsProp = findLiteralProperty(literal, 'declarations');
-    if (!declarationsProp) {
-        return;
-    }
-    const declarationsToPreserve = [];
-    const declarationsToCopy = [];
-    const properties = [];
-    const importsProp = findLiteralProperty(literal, 'imports');
-    const hasAnyArrayTrailingComma = literal.properties.some((prop) => ts__default["default"].isPropertyAssignment(prop) &&
-        ts__default["default"].isArrayLiteralExpression(prop.initializer) &&
-        prop.initializer.elements.hasTrailingComma);
-    // Separate the declarations that we want to keep and ones we need to copy into the `imports`.
-    if (ts__default["default"].isPropertyAssignment(declarationsProp)) {
-        // If the declarations are an array, we can analyze it to
-        // find any classes from the current migration.
-        if (ts__default["default"].isArrayLiteralExpression(declarationsProp.initializer)) {
-            for (const el of declarationsProp.initializer.elements) {
-                if (ts__default["default"].isIdentifier(el)) {
-                    const correspondingClass = findClassDeclaration(el, typeChecker);
-                    if (!correspondingClass ||
-                        // Check whether the declaration is either standalone already or is being converted
-                        // in this migration. We need to check if it's standalone already, in order to correct
-                        // some cases where the main app and the test files are being migrated in separate
-                        // programs.
-                        isStandaloneDeclaration(correspondingClass, allDeclarations, templateTypeChecker)) {
-                        declarationsToCopy.push(el);
-                    }
-                    else {
-                        declarationsToPreserve.push(el);
-                    }
-                }
-                else {
-                    declarationsToCopy.push(el);
-                }
-            }
-        }
-        else {
-            // Otherwise create a spread that will be copied into the `imports`.
-            declarationsToCopy.push(ts__default["default"].factory.createSpreadElement(declarationsProp.initializer));
-        }
-    }
-    // If there are no `imports`, create them with the declarations we want to copy.
-    if (!importsProp && declarationsToCopy.length > 0) {
-        properties.push(ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray(declarationsToCopy, hasAnyArrayTrailingComma && declarationsToCopy.length > 2))));
+function isStandaloneDeclaration(node, declarationsInMigration, templateTypeChecker) {
+    if (declarationsInMigration.has(node)) {
+        return true;
     }
-    for (const prop of literal.properties) {
-        if (!isNamedPropertyAssignment(prop)) {
-            properties.push(prop);
-            continue;
+    const metadata = templateTypeChecker.getDirectiveMetadata(node) || templateTypeChecker.getPipeMetadata(node);
+    return metadata != null && metadata.isStandalone;
+}
+
+/*!
+ * @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
+ */
+function pruneNgModules(program, host, basePath, rootFileNames, sourceFiles, printer, importRemapper, referenceLookupExcludedFiles, componentImportRemapper) {
+    const filesToRemove = new Set();
+    const tracker = new compiler_host.ChangeTracker(printer, importRemapper);
+    const tsProgram = program.getTsProgram();
+    const typeChecker = tsProgram.getTypeChecker();
+    const templateTypeChecker = program.compiler.getTemplateTypeChecker();
+    const referenceResolver = new ReferenceResolver(program, host, rootFileNames, basePath, referenceLookupExcludedFiles);
+    const removalLocations = {
+        arrays: new UniqueItemTracker(),
+        imports: new UniqueItemTracker(),
+        exports: new UniqueItemTracker(),
+        unknown: new Set(),
+    };
+    const classesToRemove = new Set();
+    const barrelExports = new UniqueItemTracker();
+    const componentImportArrays = new UniqueItemTracker();
+    const nodesToRemove = new Set();
+    sourceFiles.forEach(function walk(node) {
+        if (ts__default["default"].isClassDeclaration(node) && canRemoveClass(node, typeChecker)) {
+            collectChangeLocations(node, removalLocations, componentImportArrays, templateTypeChecker, referenceResolver, program);
+            classesToRemove.add(node);
         }
-        // If we have declarations to preserve, update the existing property, otherwise drop it.
-        if (prop === declarationsProp) {
-            if (declarationsToPreserve.length > 0) {
-                const hasTrailingComma = ts__default["default"].isArrayLiteralExpression(prop.initializer)
-                    ? prop.initializer.elements.hasTrailingComma
-                    : hasAnyArrayTrailingComma;
-                properties.push(ts__default["default"].factory.updatePropertyAssignment(prop, prop.name, ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray(declarationsToPreserve, hasTrailingComma && declarationsToPreserve.length > 2))));
+        else if (ts__default["default"].isExportDeclaration(node) &&
+            !node.exportClause &&
+            node.moduleSpecifier &&
+            ts__default["default"].isStringLiteralLike(node.moduleSpecifier) &&
+            node.moduleSpecifier.text.startsWith('.')) {
+            const exportedSourceFile = typeChecker
+                .getSymbolAtLocation(node.moduleSpecifier)
+                ?.valueDeclaration?.getSourceFile();
+            if (exportedSourceFile) {
+                barrelExports.track(exportedSourceFile, node);
             }
-            continue;
         }
-        // If we have an `imports` array and declarations
-        // that should be copied, we merge the two arrays.
-        if (prop === importsProp && declarationsToCopy.length > 0) {
-            let initializer;
-            if (ts__default["default"].isArrayLiteralExpression(prop.initializer)) {
-                initializer = ts__default["default"].factory.updateArrayLiteralExpression(prop.initializer, ts__default["default"].factory.createNodeArray([...prop.initializer.elements, ...declarationsToCopy], prop.initializer.elements.hasTrailingComma));
+        node.forEachChild(walk);
+    });
+    replaceInImportsArray(componentImportArrays, classesToRemove, tracker, typeChecker, templateTypeChecker, componentImportRemapper);
+    // We collect all the places where we need to remove references first before generating the
+    // removal instructions since we may have to remove multiple references from one node.
+    removeArrayReferences(removalLocations.arrays, tracker);
+    removeImportReferences(removalLocations.imports, tracker);
+    removeExportReferences(removalLocations.exports, tracker);
+    addRemovalTodos(removalLocations.unknown, tracker);
+    // Collect all the nodes to be removed before determining which files to delete since we need
+    // to know it ahead of time when deleting barrel files that export other barrel files.
+    (function trackNodesToRemove(nodes) {
+        for (const node of nodes) {
+            const sourceFile = node.getSourceFile();
+            if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodes)) {
+                const barrelExportsForFile = barrelExports.get(sourceFile);
+                nodesToRemove.add(node);
+                filesToRemove.add(sourceFile);
+                barrelExportsForFile && trackNodesToRemove(barrelExportsForFile);
             }
             else {
-                initializer = ts__default["default"].factory.createArrayLiteralExpression(ts__default["default"].factory.createNodeArray([ts__default["default"].factory.createSpreadElement(prop.initializer), ...declarationsToCopy], 
-                // Expect the declarations to be greater than 1 since
-                // we have the pre-existing initializer already.
-                hasAnyArrayTrailingComma && declarationsToCopy.length > 1));
+                nodesToRemove.add(node);
             }
-            properties.push(ts__default["default"].factory.updatePropertyAssignment(prop, prop.name, initializer));
-            continue;
         }
-        // Retain any remaining properties.
-        properties.push(prop);
+    })(classesToRemove);
+    for (const node of nodesToRemove) {
+        const sourceFile = node.getSourceFile();
+        if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodesToRemove)) {
+            filesToRemove.add(sourceFile);
+        }
+        else {
+            tracker.removeNode(node);
+        }
     }
-    tracker.replaceNode(literal, ts__default["default"].factory.updateObjectLiteralExpression(literal, ts__default["default"].factory.createNodeArray(properties, literal.properties.hasTrailingComma)), ts__default["default"].EmitHint.Expression);
-}
-/** Adds `standalone: true` to a decorator node. */
-function addStandaloneToDecorator(node) {
-    return addPropertyToAngularDecorator(node, ts__default["default"].factory.createPropertyAssignment('standalone', ts__default["default"].factory.createToken(ts__default["default"].SyntaxKind.TrueKeyword)));
+    return { pendingChanges: tracker.recordChanges(), filesToRemove };
 }
 /**
- * Adds a property to an Angular decorator node.
- * @param node Decorator to which to add the property.
- * @param property Property to add.
+ * Collects all the nodes that a module needs to be removed from.
+ * @param ngModule Module being removed.
+ * @param removalLocations Tracks the different places from which the class should be removed.
+ * @param componentImportArrays Set of `imports` arrays of components that need to be adjusted.
+ * @param referenceResolver
+ * @param program
  */
-function addPropertyToAngularDecorator(node, property) {
-    // Invalid decorator.
-    if (!ts__default["default"].isCallExpression(node.expression) || node.expression.arguments.length > 1) {
-        return node;
-    }
-    let literalProperties;
-    let hasTrailingComma = false;
-    if (node.expression.arguments.length === 0) {
-        literalProperties = [property];
-    }
-    else if (ts__default["default"].isObjectLiteralExpression(node.expression.arguments[0])) {
-        hasTrailingComma = node.expression.arguments[0].properties.hasTrailingComma;
-        literalProperties = [...node.expression.arguments[0].properties, property];
+function collectChangeLocations(ngModule, removalLocations, componentImportArrays, templateTypeChecker, referenceResolver, program) {
+    const refsByFile = referenceResolver.findReferencesInProject(ngModule.name);
+    const tsProgram = program.getTsProgram();
+    const nodes$1 = new Set();
+    for (const [fileName, refs] of refsByFile) {
+        const sourceFile = tsProgram.getSourceFile(fileName);
+        if (sourceFile) {
+            offsetsToNodes(getNodeLookup(sourceFile), refs, nodes$1);
+        }
     }
-    else {
-        // Unsupported case (e.g. `@Component(SOME_CONST)`). Return the original node.
-        return node;
+    for (const node of nodes$1) {
+        const closestArray = nodes.closestNode(node, ts__default["default"].isArrayLiteralExpression);
+        if (closestArray) {
+            const closestAssignment = nodes.closestNode(closestArray, ts__default["default"].isPropertyAssignment);
+            // If the module was flagged as being removable, but it's still being used in a standalone
+            // component's `imports` array, it means that it was likely changed outside of the migration
+            // and deleting it now will be breaking. Track it separately so it can be handled properly.
+            if (closestAssignment && isInImportsArray(closestAssignment, closestArray)) {
+                const closestDecorator = nodes.closestNode(closestAssignment, ts__default["default"].isDecorator);
+                const closestClass = closestDecorator
+                    ? nodes.closestNode(closestDecorator, ts__default["default"].isClassDeclaration)
+                    : null;
+                const directiveMeta = closestClass
+                    ? templateTypeChecker.getDirectiveMetadata(closestClass)
+                    : null;
+                if (directiveMeta && directiveMeta.isComponent && directiveMeta.isStandalone) {
+                    componentImportArrays.track(closestArray, node);
+                    continue;
+                }
+            }
+            removalLocations.arrays.track(closestArray, node);
+            continue;
+        }
+        const closestImport = nodes.closestNode(node, ts__default["default"].isNamedImports);
+        if (closestImport) {
+            removalLocations.imports.track(closestImport, node);
+            continue;
+        }
+        const closestExport = nodes.closestNode(node, ts__default["default"].isNamedExports);
+        if (closestExport) {
+            removalLocations.exports.track(closestExport, node);
+            continue;
+        }
+        removalLocations.unknown.add(node);
     }
-    // Use `createDecorator` instead of `updateDecorator`, because
-    // the latter ends up duplicating the node's leading comment.
-    return ts__default["default"].factory.createDecorator(ts__default["default"].factory.createCallExpression(node.expression.expression, node.expression.typeArguments, [
-        ts__default["default"].factory.createObjectLiteralExpression(ts__default["default"].factory.createNodeArray(literalProperties, hasTrailingComma), literalProperties.length > 1),
-    ]));
-}
-/** Checks if a node is a `PropertyAssignment` with a name. */
-function isNamedPropertyAssignment(node) {
-    return ts__default["default"].isPropertyAssignment(node) && node.name && ts__default["default"].isIdentifier(node.name);
 }
 /**
- * Finds the import from which to bring in a template dependency of a component.
- * @param target Dependency that we're searching for.
- * @param inComponent Component in which the dependency is used.
- * @param importMode Mode in which to resolve the import target.
+ * Replaces all the leftover modules in imports arrays with their exports.
+ * @param componentImportArrays All the imports arrays and their nodes that represent NgModules.
+ * @param classesToRemove Set of classes that were marked for removal.
+ * @param tracker
  * @param typeChecker
+ * @param templateTypeChecker
+ * @param importRemapper
  */
-function findImportLocation(target, inComponent, importMode, typeChecker) {
-    const importLocations = typeChecker.getPotentialImportsFor(target, inComponent, importMode);
-    let firstSameFileImport = null;
-    let firstModuleImport = null;
-    for (const location of importLocations) {
-        // Prefer a standalone import, if we can find one.
-        // Otherwise fall back to the first module-based import.
-        if (location.kind === compiler_host.PotentialImportKind.Standalone) {
-            return location;
-        }
-        if (!location.moduleSpecifier && !firstSameFileImport) {
-            firstSameFileImport = location;
+function replaceInImportsArray(componentImportArrays, classesToRemove, tracker, typeChecker, templateTypeChecker, importRemapper) {
+    for (const [array, toReplace] of componentImportArrays.getEntries()) {
+        const closestClass = nodes.closestNode(array, ts__default["default"].isClassDeclaration);
+        if (!closestClass) {
+            continue;
         }
-        if (location.kind === compiler_host.PotentialImportKind.NgModule &&
-            !firstModuleImport &&
-            // ɵ is used for some internal Angular modules that we want to skip over.
-            !location.symbolName.startsWith('ɵ')) {
-            firstModuleImport = location;
+        const replacements = new UniqueItemTracker();
+        const usedImports = new Set(findTemplateDependencies(closestClass, templateTypeChecker).map((ref) => ref.node));
+        for (const node of toReplace) {
+            const moduleDecl = findClassDeclaration(node, typeChecker);
+            if (moduleDecl) {
+                const moduleMeta = templateTypeChecker.getNgModuleMetadata(moduleDecl);
+                if (moduleMeta) {
+                    moduleMeta.exports.forEach((exp) => {
+                        if (usedImports.has(exp.node)) {
+                            replacements.track(node, exp);
+                        }
+                    });
+                }
+                else {
+                    // It's unlikely not to have module metadata at this point, but just in
+                    // case unmark the class for removal to reduce the chance of breakages.
+                    classesToRemove.delete(moduleDecl);
+                }
+            }
         }
+        replaceModulesInImportsArray(array, closestClass, replacements, tracker, templateTypeChecker, importRemapper);
     }
-    return firstSameFileImport || firstModuleImport || importLocations[0] || null;
 }
 /**
- * Checks whether a node is an `NgModule` metadata element with at least one element.
- * E.g. `declarations: [Foo]` or `declarations: SOME_VAR` would match this description,
- * but not `declarations: []`.
+ * Replaces any leftover modules in `imports` arrays with their exports that are used within a
+ * component.
+ * @param array Imports array which is being migrated.
+ * @param componentClass Class that the imports array belongs to.
+ * @param replacements Map of NgModule references to their exports.
+ * @param tracker
+ * @param templateTypeChecker
+ * @param importRemapper
  */
-function hasNgModuleMetadataElements(node) {
-    return (ts__default["default"].isPropertyAssignment(node) &&
-        (!ts__default["default"].isArrayLiteralExpression(node.initializer) || node.initializer.elements.length > 0));
-}
-/** Finds all modules whose declarations can be migrated. */
-function findNgModuleClassesToMigrate(sourceFile, typeChecker) {
-    const modules = [];
-    if (nodes.getImportSpecifier(sourceFile, '@angular/core', 'NgModule')) {
-        sourceFile.forEachChild(function walk(node) {
-            if (ts__default["default"].isClassDeclaration(node)) {
-                const decorator = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(node) || []).find((current) => current.name === 'NgModule');
-                const metadata = decorator ? extractMetadataLiteral(decorator.node) : null;
-                if (metadata) {
-                    const declarations = findLiteralProperty(metadata, 'declarations');
-                    if (declarations != null && hasNgModuleMetadataElements(declarations)) {
-                        modules.push(node);
-                    }
-                }
+function replaceModulesInImportsArray(array, componentClass, replacements, tracker, templateTypeChecker, importRemapper) {
+    const newElements = [];
+    for (const element of array.elements) {
+        const replacementRefs = replacements.get(element);
+        if (!replacementRefs) {
+            newElements.push(element);
+            continue;
+        }
+        const potentialImports = [];
+        for (const ref of replacementRefs) {
+            const importLocation = findImportLocation(ref, componentClass, compiler_host.PotentialImportMode.Normal, templateTypeChecker);
+            if (importLocation) {
+                potentialImports.push(importLocation);
             }
-            node.forEachChild(walk);
-        });
+        }
+        newElements.push(...potentialImportsToExpressions(potentialImports, componentClass, tracker, importRemapper));
     }
-    return modules;
+    tracker.replaceNode(array, ts__default["default"].factory.updateArrayLiteralExpression(array, newElements));
 }
-/** Finds all testing object literals that need to be migrated. */
-function findTestObjectsToMigrate(sourceFile, typeChecker) {
-    const testObjects = [];
-    const testBedImport = nodes.getImportSpecifier(sourceFile, '@angular/core/testing', 'TestBed');
-    const catalystImport = nodes.getImportSpecifier(sourceFile, /testing\/catalyst$/, 'setupModule');
-    if (testBedImport || catalystImport) {
-        sourceFile.forEachChild(function walk(node) {
-            const isObjectLiteralCall = ts__default["default"].isCallExpression(node) &&
-                node.arguments.length > 0 &&
-                // `arguments[0]` is the testing module config.
-                ts__default["default"].isObjectLiteralExpression(node.arguments[0]);
-            const config = isObjectLiteralCall ? node.arguments[0] : null;
-            const isTestBedCall = isObjectLiteralCall &&
-                testBedImport &&
-                ts__default["default"].isPropertyAccessExpression(node.expression) &&
-                node.expression.name.text === 'configureTestingModule' &&
-                isReferenceToImport(typeChecker, node.expression.expression, testBedImport);
-            const isCatalystCall = isObjectLiteralCall &&
-                catalystImport &&
-                ts__default["default"].isIdentifier(node.expression) &&
-                isReferenceToImport(typeChecker, node.expression, catalystImport);
-            if ((isTestBedCall || isCatalystCall) && config) {
-                const declarations = findLiteralProperty(config, 'declarations');
-                if (declarations &&
-                    ts__default["default"].isPropertyAssignment(declarations) &&
-                    ts__default["default"].isArrayLiteralExpression(declarations.initializer) &&
-                    declarations.initializer.elements.length > 0) {
-                    testObjects.push(config);
-                }
-            }
-            node.forEachChild(walk);
-        });
+/**
+ * Removes all tracked array references.
+ * @param locations Locations from which to remove the references.
+ * @param tracker Tracker in which to register the changes.
+ */
+function removeArrayReferences(locations, tracker) {
+    for (const [array, toRemove] of locations.getEntries()) {
+        const newElements = filterRemovedElements(array.elements, toRemove);
+        tracker.replaceNode(array, ts__default["default"].factory.updateArrayLiteralExpression(array, ts__default["default"].factory.createNodeArray(newElements, array.elements.hasTrailingComma)));
     }
-    return testObjects;
 }
 /**
- * Finds the classes corresponding to dependencies used in a component's template.
- * @param decl Component in whose template we're looking for dependencies.
- * @param typeChecker
+ * Removes all tracked import references.
+ * @param locations Locations from which to remove the references.
+ * @param tracker Tracker in which to register the changes.
  */
-function findTemplateDependencies(decl, typeChecker) {
-    const results = [];
-    const usedDirectives = typeChecker.getUsedDirectives(decl);
-    const usedPipes = typeChecker.getUsedPipes(decl);
-    if (usedDirectives !== null) {
-        for (const dir of usedDirectives) {
-            if (ts__default["default"].isClassDeclaration(dir.ref.node)) {
-                results.push(dir.ref);
+function removeImportReferences(locations, tracker) {
+    for (const [namedImports, toRemove] of locations.getEntries()) {
+        const newElements = filterRemovedElements(namedImports.elements, toRemove);
+        // If no imports are left, we can try to drop the entire import.
+        if (newElements.length === 0) {
+            const importClause = nodes.closestNode(namedImports, ts__default["default"].isImportClause);
+            // If the import clause has a name we can only drop then named imports.
+            // e.g. `import Foo, {ModuleToRemove} from './foo';` becomes `import Foo from './foo';`.
+            if (importClause && importClause.name) {
+                tracker.replaceNode(importClause, ts__default["default"].factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, undefined));
             }
-        }
-    }
-    if (usedPipes !== null) {
-        const potentialPipes = typeChecker.getPotentialPipes(decl);
-        for (const pipe of potentialPipes) {
-            if (ts__default["default"].isClassDeclaration(pipe.ref.node) &&
-                usedPipes.some((current) => pipe.name === current)) {
-                results.push(pipe.ref);
+            else {
+                // Otherwise we can drop the entire declaration.
+                const declaration = nodes.closestNode(namedImports, ts__default["default"].isImportDeclaration);
+                if (declaration) {
+                    tracker.removeNode(declaration);
+                }
             }
         }
+        else {
+            // Otherwise we just drop the imported symbols and keep the declaration intact.
+            tracker.replaceNode(namedImports, ts__default["default"].factory.updateNamedImports(namedImports, newElements));
+        }
     }
-    return results;
 }
 /**
- * Removes any declarations that are a part of a module's `bootstrap`
- * array from an array of declarations.
- * @param declarations Anaalyzed declarations of the module.
- * @param ngModule Module whote declarations are being filtered.
- * @param templateTypeChecker
- * @param typeChecker
+ * Removes all tracked export references.
+ * @param locations Locations from which to remove the references.
+ * @param tracker Tracker in which to register the changes.
  */
-function filterNonBootstrappedDeclarations(declarations, ngModule, templateTypeChecker, typeChecker) {
-    const metadata = templateTypeChecker.getNgModuleMetadata(ngModule);
-    const metaLiteral = metadata && metadata.decorator ? extractMetadataLiteral(metadata.decorator) : null;
-    const bootstrapProp = metaLiteral ? findLiteralProperty(metaLiteral, 'bootstrap') : null;
-    // If there's no `bootstrap`, we can't filter.
-    if (!bootstrapProp) {
-        return declarations;
-    }
-    // If we can't analyze the `bootstrap` property, we can't safely determine which
-    // declarations aren't bootstrapped so we assume that all of them are.
-    if (!ts__default["default"].isPropertyAssignment(bootstrapProp) ||
-        !ts__default["default"].isArrayLiteralExpression(bootstrapProp.initializer)) {
-        return [];
-    }
-    const bootstrappedClasses = new Set();
-    for (const el of bootstrapProp.initializer.elements) {
-        const referencedClass = ts__default["default"].isIdentifier(el) ? findClassDeclaration(el, typeChecker) : null;
-        // If we can resolve an element to a class, we can filter it out,
-        // otherwise assume that the array isn't static.
-        if (referencedClass) {
-            bootstrappedClasses.add(referencedClass);
+function removeExportReferences(locations, tracker) {
+    for (const [namedExports, toRemove] of locations.getEntries()) {
+        const newElements = filterRemovedElements(namedExports.elements, toRemove);
+        // If no exports are left, we can drop the entire declaration.
+        if (newElements.length === 0) {
+            const declaration = nodes.closestNode(namedExports, ts__default["default"].isExportDeclaration);
+            if (declaration) {
+                tracker.removeNode(declaration);
+            }
         }
         else {
-            return [];
+            // Otherwise we just drop the exported symbols and keep the declaration intact.
+            tracker.replaceNode(namedExports, ts__default["default"].factory.updateNamedExports(namedExports, newElements));
         }
     }
-    return declarations.filter((ref) => !bootstrappedClasses.has(ref));
-}
-/**
- * Extracts all classes that are referenced in a module's `declarations` array.
- * @param ngModule Module whose declarations are being extraced.
- * @param templateTypeChecker
- */
-function extractDeclarationsFromModule(ngModule, templateTypeChecker) {
-    const metadata = templateTypeChecker.getNgModuleMetadata(ngModule);
-    return metadata
-        ? metadata.declarations
-            .filter((decl) => ts__default["default"].isClassDeclaration(decl.node))
-            .map((decl) => decl.node)
-        : [];
 }
 /**
- * Migrates the `declarations` from a unit test file to standalone.
- * @param testObjects Object literals used to configure the testing modules.
- * @param declarationsOutsideOfTestFiles Non-testing declarations that are part of this migration.
- * @param tracker
- * @param templateTypeChecker
+ * Determines whether an `@NgModule` class is safe to remove. A module is safe to remove if:
+ * 1. It has no `declarations`.
+ * 2. It has no `providers`.
+ * 3. It has no `bootstrap` components.
+ * 4. It has no `ModuleWithProviders` in its `imports`.
+ * 5. It has no class members. Empty construstors are ignored.
+ * @param node Class that is being checked.
  * @param typeChecker
  */
-function migrateTestDeclarations(testObjects, declarationsOutsideOfTestFiles, tracker, templateTypeChecker, typeChecker) {
-    const { decorators, componentImports } = analyzeTestingModules(testObjects, typeChecker);
-    const allDeclarations = new Set(declarationsOutsideOfTestFiles);
-    for (const decorator of decorators) {
-        const closestClass = nodes.closestNode(decorator.node, ts__default["default"].isClassDeclaration);
-        if (decorator.name === 'Pipe' || decorator.name === 'Directive') {
-            tracker.replaceNode(decorator.node, addStandaloneToDecorator(decorator.node));
-            if (closestClass) {
-                allDeclarations.add(closestClass);
-            }
-        }
-        else if (decorator.name === 'Component') {
-            const newDecorator = addStandaloneToDecorator(decorator.node);
-            const importsToAdd = componentImports.get(decorator.node);
-            if (closestClass) {
-                allDeclarations.add(closestClass);
-            }
-            if (importsToAdd && importsToAdd.size > 0) {
-                const hasTrailingComma = importsToAdd.size > 2 &&
-                    !!extractMetadataLiteral(decorator.node)?.properties.hasTrailingComma;
-                const importsArray = ts__default["default"].factory.createNodeArray(Array.from(importsToAdd), hasTrailingComma);
-                tracker.replaceNode(decorator.node, addPropertyToAngularDecorator(newDecorator, ts__default["default"].factory.createPropertyAssignment('imports', ts__default["default"].factory.createArrayLiteralExpression(importsArray))));
+function canRemoveClass(node, typeChecker) {
+    const decorator = findNgModuleDecorator(node, typeChecker)?.node;
+    // We can't remove a declaration if it's not a valid `NgModule`.
+    if (!decorator || !ts__default["default"].isCallExpression(decorator.expression)) {
+        return false;
+    }
+    // Unsupported case, e.g. `@NgModule(SOME_VALUE)`.
+    if (decorator.expression.arguments.length > 0 &&
+        !ts__default["default"].isObjectLiteralExpression(decorator.expression.arguments[0])) {
+        return false;
+    }
+    // We can't remove modules that have class members. We make an exception for an
+    // empty constructor which may have been generated by a tool and forgotten.
+    if (node.members.length > 0 && node.members.some((member) => !isEmptyConstructor(member))) {
+        return false;
+    }
+    // An empty `NgModule` call can be removed.
+    if (decorator.expression.arguments.length === 0) {
+        return true;
+    }
+    const literal = decorator.expression.arguments[0];
+    const imports = findLiteralProperty(literal, 'imports');
+    if (imports && isNonEmptyNgModuleProperty(imports)) {
+        // We can't remove the class if at least one import isn't identifier, because it may be a
+        // `ModuleWithProviders` which is the equivalent of having something in the `providers` array.
+        for (const dep of imports.initializer.elements) {
+            if (!ts__default["default"].isIdentifier(dep)) {
+                return false;
             }
-            else {
-                tracker.replaceNode(decorator.node, newDecorator);
+            const depDeclaration = findClassDeclaration(dep, typeChecker);
+            const depNgModule = depDeclaration
+                ? findNgModuleDecorator(depDeclaration, typeChecker)
+                : null;
+            // If any of the dependencies of the class is an `NgModule` that can't be removed, the class
+            // itself can't be removed either, because it may be part of a transitive dependency chain.
+            if (depDeclaration !== null &&
+                depNgModule !== null &&
+                !canRemoveClass(depDeclaration, typeChecker)) {
+                return false;
             }
         }
     }
-    for (const obj of testObjects) {
-        moveDeclarationsToImports(obj, allDeclarations, typeChecker, templateTypeChecker, tracker);
+    // We can't remove classes that have any `declarations`, `providers` or `bootstrap` elements.
+    // Also err on the side of caution and don't remove modules where any of the aforementioned
+    // properties aren't initialized to an array literal.
+    for (const prop of literal.properties) {
+        if (isNonEmptyNgModuleProperty(prop) &&
+            (prop.name.text === 'declarations' ||
+                prop.name.text === 'providers' ||
+                prop.name.text === 'bootstrap')) {
+            return false;
+        }
     }
+    return true;
 }
 /**
- * Analyzes a set of objects used to configure testing modules and returns the AST
- * nodes that need to be migrated and the imports that should be added to the imports
- * of any declared components.
- * @param testObjects Object literals that should be analyzed.
+ * Checks whether a node is a non-empty property from an NgModule's metadata. This is defined as a
+ * property assignment with a static name, initialized to an array literal with more than one
+ * element.
+ * @param node Node to be checked.
  */
-function analyzeTestingModules(testObjects, typeChecker) {
-    const seenDeclarations = new Set();
-    const decorators = [];
-    const componentImports = new Map();
-    for (const obj of testObjects) {
-        const declarations = extractDeclarationsFromTestObject(obj, typeChecker);
-        if (declarations.length === 0) {
+function isNonEmptyNgModuleProperty(node) {
+    return (ts__default["default"].isPropertyAssignment(node) &&
+        ts__default["default"].isIdentifier(node.name) &&
+        ts__default["default"].isArrayLiteralExpression(node.initializer) &&
+        node.initializer.elements.length > 0);
+}
+/**
+ * Determines if a file is safe to delete. A file is safe to delete if all it contains are
+ * import statements, class declarations that are about to be deleted and non-exported code.
+ * @param sourceFile File that is being checked.
+ * @param nodesToBeRemoved Nodes that are being removed as a part of the migration.
+ */
+function canRemoveFile(sourceFile, nodesToBeRemoved) {
+    for (const node of sourceFile.statements) {
+        if (ts__default["default"].isImportDeclaration(node) || nodesToBeRemoved.has(node)) {
             continue;
         }
-        const importsProp = findLiteralProperty(obj, 'imports');
-        const importElements = importsProp &&
-            hasNgModuleMetadataElements(importsProp) &&
-            ts__default["default"].isArrayLiteralExpression(importsProp.initializer)
-            ? importsProp.initializer.elements.filter((el) => {
-                // Filter out calls since they may be a `ModuleWithProviders`.
-                return (!ts__default["default"].isCallExpression(el) &&
-                    // Also filter out the animations modules since they throw errors if they're imported
-                    // multiple times and it's common for apps to use the `NoopAnimationsModule` to
-                    // disable animations in screenshot tests.
-                    !isClassReferenceInAngularModule(el, /^BrowserAnimationsModule|NoopAnimationsModule$/, 'platform-browser/animations', typeChecker));
-            })
-            : null;
-        for (const decl of declarations) {
-            if (seenDeclarations.has(decl)) {
-                continue;
-            }
-            const [decorator] = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(decl) || []);
-            if (decorator) {
-                seenDeclarations.add(decl);
-                decorators.push(decorator);
-                if (decorator.name === 'Component' && importElements) {
-                    // We try to de-duplicate the imports being added to a component, because it may be
-                    // declared in different testing modules with a different set of imports.
-                    let imports = componentImports.get(decorator.node);
-                    if (!imports) {
-                        imports = new Set();
-                        componentImports.set(decorator.node, imports);
-                    }
-                    importElements.forEach((imp) => imports.add(imp));
-                }
-            }
+        if (ts__default["default"].isExportDeclaration(node) ||
+            (ts__default["default"].canHaveModifiers(node) &&
+                ts__default["default"].getModifiers(node)?.some((m) => m.kind === ts__default["default"].SyntaxKind.ExportKeyword))) {
+            return false;
         }
     }
-    return { decorators, componentImports };
+    return true;
 }
 /**
- * Finds the class declarations that are being referred
- * to in the `declarations` of an object literal.
- * @param obj Object literal that may contain the declarations.
- * @param typeChecker
+ * Gets whether an AST node contains another AST node.
+ * @param parent Parent node that may contain the child.
+ * @param child Child node that is being checked.
  */
-function extractDeclarationsFromTestObject(obj, typeChecker) {
-    const results = [];
-    const declarations = findLiteralProperty(obj, 'declarations');
-    if (declarations &&
-        hasNgModuleMetadataElements(declarations) &&
-        ts__default["default"].isArrayLiteralExpression(declarations.initializer)) {
-        for (const element of declarations.initializer.elements) {
-            const declaration = findClassDeclaration(element, typeChecker);
-            // Note that we only migrate classes that are in the same file as the testing module,
-            // because external fixture components are somewhat rare and handling them is going
-            // to involve a lot of assumptions that are likely to be incorrect.
-            if (declaration && declaration.getSourceFile().fileName === obj.getSourceFile().fileName) {
-                results.push(declaration);
+function contains(parent, child) {
+    return (parent === child ||
+        (parent.getSourceFile().fileName === child.getSourceFile().fileName &&
+            child.getStart() >= parent.getStart() &&
+            child.getStart() <= parent.getEnd()));
+}
+/**
+ * Removes AST nodes from a node array.
+ * @param elements Array from which to remove the nodes.
+ * @param toRemove Nodes that should be removed.
+ */
+function filterRemovedElements(elements, toRemove) {
+    return elements.filter((el) => {
+        for (const node of toRemove) {
+            // Check that the element contains the node, despite knowing with relative certainty that it
+            // does, because this allows us to unwrap some nodes. E.g. if we have `[((toRemove))]`, we
+            // want to remove the entire parenthesized expression, rather than just `toRemove`.
+            if (contains(el, node)) {
+                return false;
             }
         }
-    }
-    return results;
+        return true;
+    });
 }
-/** Extracts the metadata object literal from an Angular decorator. */
-function extractMetadataLiteral(decorator) {
-    // `arguments[0]` is the metadata object literal.
-    return ts__default["default"].isCallExpression(decorator.expression) &&
-        decorator.expression.arguments.length === 1 &&
-        ts__default["default"].isObjectLiteralExpression(decorator.expression.arguments[0])
-        ? decorator.expression.arguments[0]
-        : null;
+/** Returns whether a node as an empty constructor. */
+function isEmptyConstructor(node) {
+    return (ts__default["default"].isConstructorDeclaration(node) &&
+        node.parameters.length === 0 &&
+        (node.body == null || node.body.statements.length === 0));
 }
 /**
- * Checks whether a class is a standalone declaration.
- * @param node Class being checked.
- * @param declarationsInMigration Classes that are being converted to standalone in this migration.
- * @param templateTypeChecker
+ * Adds TODO comments to nodes that couldn't be removed manually.
+ * @param nodes Nodes to which to add the TODO.
+ * @param tracker Tracker in which to register the changes.
  */
-function isStandaloneDeclaration(node, declarationsInMigration, templateTypeChecker) {
-    if (declarationsInMigration.has(node)) {
-        return true;
+function addRemovalTodos(nodes, tracker) {
+    for (const node of nodes) {
+        // Note: the comment is inserted using string manipulation, instead of going through the AST,
+        // because this way we preserve more of the app's original formatting.
+        // Note: in theory this can duplicate comments if the module pruning runs multiple times on
+        // the same node. In practice it is unlikely, because the second time the node won't be picked
+        // up by the language service as a reference, because the class won't exist anymore.
+        tracker.insertText(node.getSourceFile(), node.getFullStart(), ` /* TODO(standalone-migration): clean up removed NgModule reference manually. */ `);
     }
-    const metadata = templateTypeChecker.getDirectiveMetadata(node) || templateTypeChecker.getPipeMetadata(node);
-    return metadata != null && metadata.isStandalone;
+}
+/** Finds the `NgModule` decorator in a class, if it exists. */
+function findNgModuleDecorator(node, typeChecker) {
+    const decorators = nodes.getAngularDecorators(typeChecker, ts__default["default"].getDecorators(node) || []);
+    return decorators.find((decorator) => decorator.name === 'NgModule') || null;
+}
+/**
+ * Checks whether a node is used inside of an `imports` array.
+ * @param closestAssignment The closest property assignment to the node.
+ * @param closestArray The closest array to the node.
+ */
+function isInImportsArray(closestAssignment, closestArray) {
+    return (closestAssignment.initializer === closestArray &&
+        (ts__default["default"].isIdentifier(closestAssignment.name) || ts__default["default"].isStringLiteralLike(closestAssignment.name)) &&
+        closestAssignment.name.text === 'imports');
 }
 
 /*!
@@ -22297,7 +22399,7 @@ function standaloneMigration(tree, tsconfigPath, basePath, pathToMigrate, schema
     let pendingChanges;
     let filesToRemove = null;
     if (schematicOptions.mode === MigrationMode.pruneModules) {
-        const result = pruneNgModules(program, host, basePath, rootNames, sourceFiles, printer, undefined, referenceLookupExcludedFiles);
+        const result = pruneNgModules(program, host, basePath, rootNames, sourceFiles, printer, undefined, referenceLookupExcludedFiles, knownInternalAliasRemapper);
         pendingChanges = result.pendingChanges;
         filesToRemove = result.filesToRemove;
     }