@angular/core 19.2.0-next.2 → 19.2.0-rc.0

package/schematics/bundles/self-closing-tags-migration.js

@@ -0,0 +1,448 @@
+'use strict';
+/**
+ * @license Angular v19.2.0-rc.0
+ * (c) 2010-2024 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var schematics = require('@angular-devkit/schematics');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
+var project_paths = require('./project_paths-b073c4d6.js');
+require('os');
+var ts = require('typescript');
+var checker = require('./checker-2eecc677.js');
+require('./program-24da9092.js');
+require('path');
+var ng_decorators = require('./ng_decorators-e699c081.js');
+var property_name = require('./property_name-7c8433f5.js');
+require('@angular-devkit/core');
+require('node:path/posix');
+require('fs');
+require('module');
+require('url');
+require('./imports-abe29092.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+/**
+ * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
+ * parentheses or as expression. e.g. "(((({exp}))))()". The function should return the
+ * TypeScript node referring to the inner expression. e.g "exp".
+ */
+function unwrapExpression(node) {
+    if (ts__default["default"].isParenthesizedExpression(node) || ts__default["default"].isAsExpression(node)) {
+        return unwrapExpression(node.expression);
+    }
+    else {
+        return node;
+    }
+}
+
+/** Extracts `@Directive` or `@Component` metadata from the given class. */
+function extractAngularClassMetadata(typeChecker, node) {
+    const decorators = ts__default["default"].getDecorators(node);
+    if (!decorators || !decorators.length) {
+        return null;
+    }
+    const ngDecorators = ng_decorators.getAngularDecorators(typeChecker, decorators);
+    const componentDecorator = ngDecorators.find((dec) => dec.name === 'Component');
+    const directiveDecorator = ngDecorators.find((dec) => dec.name === 'Directive');
+    const decorator = componentDecorator ?? directiveDecorator;
+    // In case no decorator could be found on the current class, skip.
+    if (!decorator) {
+        return null;
+    }
+    const decoratorCall = decorator.node.expression;
+    // In case the decorator call is not valid, skip this class declaration.
+    if (decoratorCall.arguments.length !== 1) {
+        return null;
+    }
+    const metadata = unwrapExpression(decoratorCall.arguments[0]);
+    // Ensure that the metadata is an object literal expression.
+    if (!ts__default["default"].isObjectLiteralExpression(metadata)) {
+        return null;
+    }
+    return {
+        type: componentDecorator ? 'component' : 'directive',
+        node: metadata,
+    };
+}
+
+const LF_CHAR = 10;
+const CR_CHAR = 13;
+const LINE_SEP_CHAR = 8232;
+const PARAGRAPH_CHAR = 8233;
+/** Gets the line and character for the given position from the line starts map. */
+function getLineAndCharacterFromPosition(lineStartsMap, position) {
+    const lineIndex = findClosestLineStartPosition(lineStartsMap, position);
+    return { character: position - lineStartsMap[lineIndex], line: lineIndex };
+}
+/**
+ * Computes the line start map of the given text. This can be used in order to
+ * retrieve the line and character of a given text position index.
+ */
+function computeLineStartsMap(text) {
+    const result = [0];
+    let pos = 0;
+    while (pos < text.length) {
+        const char = text.charCodeAt(pos++);
+        // Handles the "CRLF" line break. In that case we peek the character
+        // after the "CR" and check if it is a line feed.
+        if (char === CR_CHAR) {
+            if (text.charCodeAt(pos) === LF_CHAR) {
+                pos++;
+            }
+            result.push(pos);
+        }
+        else if (char === LF_CHAR || char === LINE_SEP_CHAR || char === PARAGRAPH_CHAR) {
+            result.push(pos);
+        }
+    }
+    result.push(pos);
+    return result;
+}
+/** Finds the closest line start for the given position. */
+function findClosestLineStartPosition(linesMap, position, low = 0, high = linesMap.length - 1) {
+    while (low <= high) {
+        const pivotIdx = Math.floor((low + high) / 2);
+        const pivotEl = linesMap[pivotIdx];
+        if (pivotEl === position) {
+            return pivotIdx;
+        }
+        else if (position > pivotEl) {
+            low = pivotIdx + 1;
+        }
+        else {
+            high = pivotIdx - 1;
+        }
+    }
+    // In case there was no exact match, return the closest "lower" line index. We also
+    // subtract the index by one because want the index of the previous line start.
+    return low - 1;
+}
+
+/**
+ * Visitor that can be used to determine Angular templates referenced within given
+ * TypeScript source files (inline templates or external referenced templates)
+ */
+class NgComponentTemplateVisitor {
+    typeChecker;
+    resolvedTemplates = [];
+    fs = checker.getFileSystem();
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
+    }
+    visitNode(node) {
+        if (node.kind === ts__default["default"].SyntaxKind.ClassDeclaration) {
+            this.visitClassDeclaration(node);
+        }
+        ts__default["default"].forEachChild(node, (n) => this.visitNode(n));
+    }
+    visitClassDeclaration(node) {
+        const metadata = extractAngularClassMetadata(this.typeChecker, node);
+        if (metadata === null || metadata.type !== 'component') {
+            return;
+        }
+        const sourceFile = node.getSourceFile();
+        const sourceFileName = sourceFile.fileName;
+        // Walk through all component metadata properties and determine the referenced
+        // HTML templates (either external or inline)
+        metadata.node.properties.forEach((property) => {
+            if (!ts__default["default"].isPropertyAssignment(property)) {
+                return;
+            }
+            const propertyName = property_name.getPropertyNameText(property.name);
+            // In case there is an inline template specified, ensure that the value is statically
+            // analyzable by checking if the initializer is a string literal-like node.
+            if (propertyName === 'template' && ts__default["default"].isStringLiteralLike(property.initializer)) {
+                // Need to add an offset of one to the start because the template quotes are
+                // not part of the template content.
+                // The `getText()` method gives us the original raw text.
+                // We could have used the `text` property, but if the template is defined as a backtick
+                // string then the `text` property contains a "cooked" version of the string. Such cooked
+                // strings will have converted CRLF characters to only LF. This messes up string
+                // replacements in template migrations.
+                // The raw text returned by `getText()` includes the enclosing quotes so we change the
+                // `content` and `start` values accordingly.
+                const content = property.initializer.getText().slice(1, -1);
+                const start = property.initializer.getStart() + 1;
+                this.resolvedTemplates.push({
+                    filePath: sourceFileName,
+                    container: node,
+                    content,
+                    inline: true,
+                    start: start,
+                    getCharacterAndLineOfPosition: (pos) => ts__default["default"].getLineAndCharacterOfPosition(sourceFile, pos + start),
+                });
+            }
+            if (propertyName === 'templateUrl' && ts__default["default"].isStringLiteralLike(property.initializer)) {
+                const absolutePath = this.fs.resolve(this.fs.dirname(sourceFileName), property.initializer.text);
+                if (!this.fs.exists(absolutePath)) {
+                    return;
+                }
+                const fileContent = this.fs.readFile(absolutePath);
+                const lineStartsMap = computeLineStartsMap(fileContent);
+                this.resolvedTemplates.push({
+                    filePath: absolutePath,
+                    container: node,
+                    content: fileContent,
+                    inline: false,
+                    start: 0,
+                    getCharacterAndLineOfPosition: (pos) => getLineAndCharacterFromPosition(lineStartsMap, pos),
+                });
+            }
+        });
+    }
+}
+
+function parseTemplate(template) {
+    let parsed;
+    try {
+        // Note: we use the HtmlParser here, instead of the `parseTemplate` function, because the
+        // latter returns an Ivy AST, not an HTML AST. The HTML AST has the advantage of preserving
+        // interpolated text as text nodes containing a mixture of interpolation tokens and text tokens,
+        // rather than turning them into `BoundText` nodes like the Ivy AST does. This allows us to
+        // easily get the text-only ranges without having to reconstruct the original text.
+        parsed = new checker.HtmlParser().parse(template, '', {
+            // Allows for ICUs to be parsed.
+            tokenizeExpansionForms: true,
+            // Explicitly disable blocks so that their characters are treated as plain text.
+            tokenizeBlocks: true,
+            preserveLineEndings: true,
+        });
+        // Don't migrate invalid templates.
+        if (parsed.errors && parsed.errors.length > 0) {
+            const errors = parsed.errors.map((e) => ({ type: 'parse', error: e }));
+            return { tree: undefined, errors };
+        }
+    }
+    catch (e) {
+        return { tree: undefined, errors: [{ type: 'parse', error: e }] };
+    }
+    return { tree: parsed, errors: [] };
+}
+
+function migrateTemplateToSelfClosingTags(template) {
+    let parsed = parseTemplate(template);
+    if (parsed.tree === undefined) {
+        return { migrated: template, changed: false, replacementCount: 0 };
+    }
+    const visitor = new AngularElementCollector();
+    checker.visitAll(visitor, parsed.tree.rootNodes);
+    let newTemplate = template;
+    let changedOffset = 0;
+    let replacementCount = 0;
+    for (let element of visitor.elements) {
+        const { start, end, tagName } = element;
+        const currentLength = newTemplate.length;
+        const templatePart = newTemplate.slice(start + changedOffset, end + changedOffset);
+        const convertedTemplate = replaceWithSelfClosingTag(templatePart, tagName);
+        // if the template has changed, replace the original template with the new one
+        if (convertedTemplate.length !== templatePart.length) {
+            newTemplate = replaceTemplate(newTemplate, convertedTemplate, start, end, changedOffset);
+            changedOffset += newTemplate.length - currentLength;
+            replacementCount++;
+        }
+    }
+    return { migrated: newTemplate, changed: changedOffset !== 0, replacementCount };
+}
+function replaceWithSelfClosingTag(html, tagName) {
+    const pattern = new RegExp(`<\\s*${tagName}\\s*([^>]*?(?:"[^"]*"|'[^']*'|[^'">])*)\\s*>([\\s\\S]*?)<\\s*/\\s*${tagName}\\s*>`, 'gi');
+    return html.replace(pattern, (_, content) => `<${tagName}${content ? ` ${content}` : ''} />`);
+}
+/**
+ * Replace the value in the template with the new value based on the start and end position + offset
+ */
+function replaceTemplate(template, replaceValue, start, end, offset) {
+    return template.slice(0, start + offset) + replaceValue + template.slice(end + offset);
+}
+const ALL_HTML_TAGS = new checker.DomElementSchemaRegistry().allKnownElementNames();
+class AngularElementCollector extends checker.RecursiveVisitor {
+    elements = [];
+    constructor() {
+        super();
+    }
+    visitElement(element) {
+        const isHtmlTag = ALL_HTML_TAGS.includes(element.name);
+        if (isHtmlTag) {
+            return;
+        }
+        const hasNoContent = this.elementHasNoContent(element);
+        const hasNoClosingTag = this.elementHasNoClosingTag(element);
+        if (hasNoContent && !hasNoClosingTag) {
+            this.elements.push({
+                tagName: element.name,
+                start: element.sourceSpan.start.offset,
+                end: element.sourceSpan.end.offset,
+            });
+        }
+        return super.visitElement(element, null);
+    }
+    elementHasNoContent(element) {
+        if (!element.children?.length) {
+            return true;
+        }
+        if (element.children.length === 1) {
+            const child = element.children[0];
+            return child instanceof checker.Text && /^\s*$/.test(child.value);
+        }
+        return false;
+    }
+    elementHasNoClosingTag(element) {
+        const { startSourceSpan, endSourceSpan } = element;
+        if (!endSourceSpan) {
+            return true;
+        }
+        return (startSourceSpan.start.offset === endSourceSpan.start.offset &&
+            startSourceSpan.end.offset === endSourceSpan.end.offset);
+    }
+}
+
+class SelfClosingTagsMigration extends project_paths.TsurgeFunnelMigration {
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async analyze(info) {
+        const { sourceFiles, program } = info;
+        const typeChecker = program.getTypeChecker();
+        const tagReplacements = [];
+        for (const sf of sourceFiles) {
+            ts__default["default"].forEachChild(sf, (node) => {
+                if (!ts__default["default"].isClassDeclaration(node)) {
+                    return;
+                }
+                const file = project_paths.projectFile(node.getSourceFile(), info);
+                if (this.config.shouldMigrate && this.config.shouldMigrate(file) === false) {
+                    return;
+                }
+                const templateVisitor = new NgComponentTemplateVisitor(typeChecker);
+                templateVisitor.visitNode(node);
+                templateVisitor.resolvedTemplates.forEach((template) => {
+                    const { migrated, changed, replacementCount } = migrateTemplateToSelfClosingTags(template.content);
+                    if (changed) {
+                        const fileToMigrate = template.inline
+                            ? file
+                            : project_paths.projectFile(template.filePath, info);
+                        const end = template.start + template.content.length;
+                        const replacements = [
+                            prepareTextReplacement(fileToMigrate, migrated, template.start, end),
+                        ];
+                        const fileReplacements = tagReplacements.find((tagReplacement) => tagReplacement.file === file);
+                        if (fileReplacements) {
+                            fileReplacements.replacements.push(...replacements);
+                            fileReplacements.replacementCount += replacementCount;
+                        }
+                        else {
+                            tagReplacements.push({ file, replacements, replacementCount });
+                        }
+                    }
+                });
+            });
+        }
+        return project_paths.confirmAsSerializable({ tagReplacements });
+    }
+    async combine(unitA, unitB) {
+        return project_paths.confirmAsSerializable({
+            tagReplacements: unitA.tagReplacements.concat(unitB.tagReplacements),
+        });
+    }
+    async globalMeta(combinedData) {
+        const globalMeta = {
+            tagReplacements: combinedData.tagReplacements,
+        };
+        return project_paths.confirmAsSerializable(globalMeta);
+    }
+    async stats(globalMetadata) {
+        const touchedFilesCount = globalMetadata.tagReplacements.length;
+        const replacementCount = globalMetadata.tagReplacements.reduce((acc, cur) => acc + cur.replacementCount, 0);
+        return {
+            counters: {
+                touchedFilesCount,
+                replacementCount,
+            },
+        };
+    }
+    async migrate(globalData) {
+        return { replacements: globalData.tagReplacements.flatMap(({ replacements }) => replacements) };
+    }
+}
+function prepareTextReplacement(file, replacement, start, end) {
+    return new project_paths.Replacement(file, new project_paths.TextUpdate({
+        position: start,
+        end: end,
+        toInsert: replacement,
+    }));
+}
+
+function migrate(options) {
+    return async (tree, context) => {
+        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
+        if (!buildPaths.length && !testPaths.length) {
+            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run self-closing tags migration.');
+        }
+        const fs = new project_paths.DevkitMigrationFilesystem(tree);
+        checker.setFileSystem(fs);
+        const migration = new SelfClosingTagsMigration({
+            shouldMigrate: (file) => {
+                return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
+                    !/(^|\/)node_modules\//.test(file.rootRelativePath));
+            },
+        });
+        const unitResults = [];
+        const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
+            context.logger.info(`Preparing analysis for: ${tsconfigPath}..`);
+            const baseInfo = migration.createProgram(tsconfigPath, fs);
+            const info = migration.prepareProgram(baseInfo);
+            return { info, tsconfigPath };
+        });
+        // Analyze phase. Treat all projects as compilation units as
+        // this allows us to support references between those.
+        for (const { info, tsconfigPath } of programInfos) {
+            context.logger.info(`Scanning for component tags: ${tsconfigPath}..`);
+            unitResults.push(await migration.analyze(info));
+        }
+        context.logger.info(``);
+        context.logger.info(`Processing analysis data between targets..`);
+        context.logger.info(``);
+        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
+        if (combined === null) {
+            context.logger.error('Migration failed unexpectedly with no analysis data');
+            return;
+        }
+        const globalMeta = await migration.globalMeta(combined);
+        const replacementsPerFile = new Map();
+        for (const { tsconfigPath } of programInfos) {
+            context.logger.info(`Migrating: ${tsconfigPath}..`);
+            const { replacements } = await migration.migrate(globalMeta);
+            const changesPerFile = project_paths.groupReplacementsByFile(replacements);
+            for (const [file, changes] of changesPerFile) {
+                if (!replacementsPerFile.has(file)) {
+                    replacementsPerFile.set(file, changes);
+                }
+            }
+        }
+        context.logger.info(`Applying changes..`);
+        for (const [file, changes] of replacementsPerFile) {
+            const recorder = tree.beginUpdate(file);
+            for (const c of changes) {
+                recorder
+                    .remove(c.data.position, c.data.end - c.data.position)
+                    .insertLeft(c.data.position, c.data.toInsert);
+            }
+            tree.commitUpdate(recorder);
+        }
+        const { counters: { touchedFilesCount, replacementCount }, } = await migration.stats(globalMeta);
+        context.logger.info('');
+        context.logger.info(`Successfully migrated to self-closing tags 🎉`);
+        context.logger.info(`  -> Migrated ${replacementCount} components to self-closing tags in ${touchedFilesCount} component files.`);
+    };
+}
+
+exports.migrate = migrate;

package/schematics/bundles/signal-input-migration.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.2.0-next.2
+ * @license Angular v19.2.0-rc.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -9,17 +9,18 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
-var migrate_ts_type_references = require('./migrate_ts_type_references-c6615b87.js');
+var migrate_ts_type_references = require('./migrate_ts_type_references-71b3a951.js');
 var ts = require('typescript');
 require('os');
-var checker = require('./checker-9af84be9.js');
-var program = require('./program-66386e72.js');
+var checker = require('./checker-2eecc677.js');
+var program = require('./program-24da9092.js');
 require('path');
-var apply_import_manager = require('./apply_import_manager-d8ea426b.js');
-var index = require('./index-23b503a4.js');
+var project_paths = require('./project_paths-b073c4d6.js');
+var index = require('./index-24a2ad1e.js');
 var assert = require('assert');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-require('./leading_space-6e7a8ec6.js');
+var apply_import_manager = require('./apply_import_manager-a930fcf1.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
+require('./leading_space-d190b83b.js');
 require('fs');
 require('module');
 require('url');
@@ -108,7 +109,7 @@ function getInputDescriptor(hostOrInfo, node) {
         className = node.parent.name?.text ?? '<anonymous>';
     }
     const info = hostOrInfo instanceof MigrationHost ? hostOrInfo.programInfo : hostOrInfo;
-    const file = apply_import_manager.projectFile(node.getSourceFile(), info);
+    const file = project_paths.projectFile(node.getSourceFile(), info);
     // Inputs may be detected in `.d.ts` files. Ensure that if the file IDs
     // match regardless of extension. E.g. `/google3/blaze-out/bin/my_file.ts` should
     // have the same ID as `/google3/my_file.ts`.
@@ -187,7 +188,7 @@ class KnownInputs {
         }
         const directiveInfo = this._classToDirectiveInfo.get(data.node.parent);
         const inputInfo = {
-            file: apply_import_manager.projectFile(data.node.getSourceFile(), this.programInfo),
+            file: project_paths.projectFile(data.node.getSourceFile(), this.programInfo),
             metadata: data.metadata,
             descriptor: data.descriptor,
             container: directiveInfo,
@@ -1041,7 +1042,7 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
     if (leadingTodoText !== null) {
         replacements.push(migrate_ts_type_references.insertPrecedingLine(node, info, '// TODO: Notes from signal input migration:'), ...migrate_ts_type_references.cutStringToLineLimit(leadingTodoText, 70).map((line) => migrate_ts_type_references.insertPrecedingLine(node, info, `//  ${line}`)));
     }
-    replacements.push(new apply_import_manager.Replacement(apply_import_manager.projectFile(node.getSourceFile(), info), new apply_import_manager.TextUpdate({
+    replacements.push(new project_paths.Replacement(project_paths.projectFile(node.getSourceFile(), info), new project_paths.TextUpdate({
         position: node.getStart(),
         end: node.getEnd(),
         toInsert: newPropertyText,
@@ -1159,7 +1160,7 @@ function pass7__migrateTemplateReferences(host, references) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new apply_import_manager.Replacement(reference.from.templateFile, new apply_import_manager.TextUpdate({
+        host.replacements.push(new project_paths.Replacement(reference.from.templateFile, new project_paths.TextUpdate({
             position: reference.from.read.sourceSpan.end,
             end: reference.from.read.sourceSpan.end,
             toInsert: appendText,
@@ -1199,7 +1200,7 @@ function pass8__migrateHostBindings(host, references, info) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new apply_import_manager.Replacement(apply_import_manager.projectFile(bindingField.getSourceFile(), info), new apply_import_manager.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
+        host.replacements.push(new project_paths.Replacement(project_paths.projectFile(bindingField.getSourceFile(), info), new project_paths.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
     }
 }
 
@@ -1262,7 +1263,7 @@ function filterIncompatibilitiesForBestEffortMode(knownInputs) {
  * Tsurge migration for migrating Angular `@Input()` declarations to
  * signal inputs, with support for batch execution.
  */
-class SignalInputMigration extends apply_import_manager.TsurgeComplexMigration {
+class SignalInputMigration extends project_paths.TsurgeComplexMigration {
     config;
     upgradedAnalysisPhaseResults = null;
     constructor(config = {}) {
@@ -1271,7 +1272,7 @@ class SignalInputMigration extends apply_import_manager.TsurgeComplexMigration {
     }
     // Override the default program creation, to add extra flags.
     createProgram(tsconfigAbsPath, fs) {
-        return apply_import_manager.createBaseProgramInfo(tsconfigAbsPath, fs, {
+        return project_paths.createBaseProgramInfo(tsconfigAbsPath, fs, {
             _compilePoisonedComponents: true,
             // We want to migrate non-exported classes too.
             compileNonExportedClasses: true,
@@ -1343,13 +1344,13 @@ class SignalInputMigration extends apply_import_manager.TsurgeComplexMigration {
                 knownInputs,
             };
         }
-        return apply_import_manager.confirmAsSerializable(unitData);
+        return project_paths.confirmAsSerializable(unitData);
     }
     async combine(unitA, unitB) {
-        return apply_import_manager.confirmAsSerializable(combineCompilationUnitData(unitA, unitB));
+        return project_paths.confirmAsSerializable(combineCompilationUnitData(unitA, unitB));
     }
     async globalMeta(combinedData) {
-        return apply_import_manager.confirmAsSerializable(convertToGlobalMeta(combinedData));
+        return project_paths.confirmAsSerializable(convertToGlobalMeta(combinedData));
     }
     async migrate(globalMetadata, info, nonBatchData) {
         const knownInputs = nonBatchData?.knownInputs ?? new KnownInputs(info, this.config);
@@ -1443,7 +1444,7 @@ function migrate(options) {
         if (!buildPaths.length && !testPaths.length) {
             throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run signal input migration.');
         }
-        const fs = new apply_import_manager.DevkitMigrationFilesystem(tree);
+        const fs = new project_paths.DevkitMigrationFilesystem(tree);
         checker.setFileSystem(fs);
         const migration = new SignalInputMigration({
             bestEffortMode: options.bestEffortMode,
@@ -1475,7 +1476,7 @@ function migrate(options) {
         context.logger.info(``);
         context.logger.info(`Processing analysis data between targets..`);
         context.logger.info(``);
-        const combined = await apply_import_manager.synchronouslyCombineUnitData(migration, unitResults);
+        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
         if (combined === null) {
             context.logger.error('Migration failed unexpectedly with no analysis data');
             return;
@@ -1485,7 +1486,7 @@ function migrate(options) {
         for (const { info, tsconfigPath } of programInfos) {
             context.logger.info(`Migrating: ${tsconfigPath}..`);
             const { replacements } = await migration.migrate(globalMeta, info);
-            const changesPerFile = apply_import_manager.groupReplacementsByFile(replacements);
+            const changesPerFile = project_paths.groupReplacementsByFile(replacements);
             for (const [file, changes] of changesPerFile) {
                 if (!replacementsPerFile.has(file)) {
                     replacementsPerFile.set(file, changes);