@angular/core 19.0.0-next.8 → 19.0.0-rc.0

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.8
+ * @license Angular v19.0.0-rc.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -9,147 +9,57 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
-var group_replacements = require('./group_replacements-472b2387.js');
+var migrate_ts_type_references = require('./migrate_ts_type_references-ab18a7c3.js');
 var ts = require('typescript');
 require('os');
-var checker = require('./checker-e68dd7ce.js');
-var program = require('./program-105283c5.js');
+var checker = require('./checker-2451e7c5.js');
+var program = require('./program-58424797.js');
 require('path');
+var combine_units = require('./combine_units-c52492ab.js');
 var assert = require('assert');
-var leading_space = require('./leading_space-d190b83b.js');
-var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
-require('@angular-devkit/core');
-require('node:path');
+var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
+require('./leading_space-6e7a8ec6.js');
 require('fs');
 require('module');
 require('url');
+require('@angular-devkit/core');
+require('node:path/posix');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
 
-/**
- * Gets human-readable message information for the given input incompatibility.
- * This text will be used by the language service, or CLI-based migration.
- */
-function getMessageForInputIncompatibility(reason) {
-    switch (reason) {
-        case group_replacements.InputIncompatibilityReason.Accessor:
-            return {
-                short: 'Accessor inputs cannot be migrated as they are too complex.',
-                extra: 'The migration potentially requires usage of `effect` or `computed`, but ' +
-                    'the intent is unclear. The migration cannot safely migrate.',
-            };
-        case group_replacements.InputIncompatibilityReason.OverriddenByDerivedClass:
-            return {
-                short: 'The input cannot be migrated because the field is overridden by a subclass.',
-                extra: 'The field in the subclass is not an input, so migrating would break your build.',
-            };
-        case group_replacements.InputIncompatibilityReason.ParentIsIncompatible:
-            return {
-                short: 'This input is inherited from a superclass, but the parent cannot be migrated.',
-                extra: 'Migrating this input would cause your build to fail.',
-            };
-        case group_replacements.InputIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet:
-            return {
-                short: 'This input is used in a control flow expression (e.g. `@if` or `*ngIf`) and ' +
-                    'migrating would break narrowing currently.',
-                extra: `In the future, Angular intends to support narrowing of signals.`,
-            };
-        case group_replacements.InputIncompatibilityReason.RedeclaredViaDerivedClassInputsArray:
-            return {
-                short: 'The input is overridden by a subclass that cannot be migrated.',
-                extra: 'The subclass re-declares this input via the `inputs` array in @Directive/@Component. ' +
-                    'Migrating this input would break your build because the subclass input cannot be migrated.',
-            };
-        case group_replacements.InputIncompatibilityReason.RequiredInputButNoGoodExplicitTypeExtractable:
-            return {
-                short: `Input is required, but the migration cannot determine a good type for the input.`,
-                extra: 'Consider adding an explicit type to make the migration possible.',
-            };
-        case group_replacements.InputIncompatibilityReason.InputWithQuestionMarkButNoGoodExplicitTypeExtractable:
-            return {
-                short: `Input is marked with a question mark. Migration could not determine a good type for the input.`,
-                extra: 'The migration needs to be able to resolve a type, so that it can include `undefined` in your type. ' +
-                    'Consider adding an explicit type to make the migration possible.',
-            };
-        case group_replacements.InputIncompatibilityReason.SkippedViaConfigFilter:
-            return {
-                short: `This input is not part of the current migration scope.`,
-                extra: 'Skipped via migration config.',
-            };
-        case group_replacements.InputIncompatibilityReason.SpyOnThatOverwritesField:
-            return {
-                short: 'A jasmine `spyOn` call spies on this input. This breaks with signal inputs.',
-                extra: `Migration cannot safely migrate as "spyOn" writes to the input. Signal inputs are readonly.`,
-            };
-        case group_replacements.InputIncompatibilityReason.TypeConflictWithBaseClass:
-            return {
-                short: 'This input overrides a field from a superclass, while the superclass field is not migrated.',
-                extra: 'Migrating the input would break your build because of a type conflict then.',
-            };
-        case group_replacements.InputIncompatibilityReason.WriteAssignment:
-            return {
-                short: 'Your application code writes to the input. This prevents migration.',
-                extra: 'Signal inputs are readonly, so migrating would break your build.',
-            };
-        case group_replacements.InputIncompatibilityReason.OutsideOfMigrationScope:
-            return {
-                short: 'This input is not part of any source files in your project.',
-                extra: 'The migration excludes inputs if no source file declaring the input was seen.',
-            };
-    }
-}
-/**
- * Gets human-readable message information for the given input class incompatibility.
- * This text will be used by the language service, or CLI-based migration.
- */
-function getMessageForClassIncompatibility(reason) {
-    switch (reason) {
-        case group_replacements.ClassIncompatibilityReason.InputOwningClassReferencedInClassProperty:
-            return {
-                short: 'Class of this input is referenced in the signature of another class.',
-                extra: 'The other class is likely typed to expect a non-migrated field, so ' +
-                    'migration is skipped to not break your build.',
-            };
-        case group_replacements.ClassIncompatibilityReason.ClassManuallyInstantiated:
-            return {
-                short: 'Class of this input is manually instantiated. ' +
-                    'This is discouraged and prevents migration',
-                extra: 'Signal inputs require a DI injection context. Manually instantiating ' +
-                    'breaks this requirement in some cases, so the migration is skipped.',
-            };
-    }
-}
-
 /**
  * Class that holds information about a given directive and its input fields.
  */
 class DirectiveInfo {
+    clazz;
+    /**
+     * Map of inputs detected in the given class.
+     * Maps string-based input ids to the detailed input metadata.
+     */
+    inputFields = new Map();
+    /** Map of input IDs and their incompatibilities. */
+    memberIncompatibility = new Map();
+    /**
+     * Whether the whole class is incompatible.
+     *
+     * Class incompatibility precedes individual member incompatibility.
+     * All members in the class are considered incompatible.
+     */
+    incompatible = null;
     constructor(clazz) {
         this.clazz = clazz;
-        /**
-         * Map of inputs detected in the given class.
-         * Maps string-based input ids to the detailed input metadata.
-         */
-        this.inputFields = new Map();
-        /** Map of input IDs and their incompatibilities. */
-        this.memberIncompatibility = new Map();
-        /**
-         * Whether the whole class is incompatible.
-         *
-         * Class incompatibility precedes individual member incompatibility.
-         * All members in the class are considered incompatible.
-         */
-        this.incompatible = null;
     }
     /**
-     * Checks whether there are any incompatible inputs for the
+     * Checks whether there are any migrated inputs for the
      * given class.
+     *
+     * Returns `false` if all inputs are incompatible.
      */
-    hasIncompatibleMembers() {
-        return Array.from(this.inputFields.values()).some(({ descriptor }) => this.isInputMemberIncompatible(descriptor));
+    hasMigratedFields() {
+        return Array.from(this.inputFields.values()).some(({ descriptor }) => !this.isInputMemberIncompatible(descriptor));
     }
     /**
      * Whether the given input member is incompatible. If the class is incompatible,
@@ -170,6 +80,11 @@ class DirectiveInfo {
  * the whole migration.
  */
 class MigrationHost {
+    isMigratingCore;
+    programInfo;
+    config;
+    _sourceFiles;
+    compilerOptions;
     constructor(isMigratingCore, programInfo, config, sourceFiles) {
         this.isMigratingCore = isMigratingCore;
         this.programInfo = programInfo;
@@ -192,7 +107,7 @@ function getInputDescriptor(hostOrInfo, node) {
         className = node.parent.name?.text ?? '<anonymous>';
     }
     const info = hostOrInfo instanceof MigrationHost ? hostOrInfo.programInfo : hostOrInfo;
-    const file = group_replacements.projectFile(node.getSourceFile(), info);
+    const file = combine_units.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`.
@@ -202,11 +117,6 @@ function getInputDescriptor(hostOrInfo, node) {
         node,
     };
 }
-/** Whether the given value is an input descriptor. */
-function isInputDescriptor(v) {
-    return (v.key !== undefined &&
-        v.node !== undefined);
-}
 
 /**
  * Attempts to resolve the known `@Input` metadata for the given
@@ -216,11 +126,11 @@ function attemptRetrieveInputFromSymbol(programInfo, memberSymbol, knownInputs)
     // Even for declared classes from `.d.ts`, the value declaration
     // should exist and point to the property declaration.
     if (memberSymbol.valueDeclaration !== undefined &&
-        group_replacements.isInputContainerNode(memberSymbol.valueDeclaration)) {
+        combine_units.isInputContainerNode(memberSymbol.valueDeclaration)) {
         const member = memberSymbol.valueDeclaration;
         // If the member itself is an input that is being migrated, we
         // do not need to check, as overriding would be fine then— like before.
-        const memberInputDescr = group_replacements.isInputContainerNode(member)
+        const memberInputDescr = combine_units.isInputContainerNode(member)
             ? getInputDescriptor(programInfo, member)
             : null;
         return memberInputDescr !== null ? (knownInputs.get(memberInputDescr) ?? null) : null;
@@ -235,17 +145,19 @@ function attemptRetrieveInputFromSymbol(programInfo, memberSymbol, knownInputs)
  * loaded into the program.
  */
 class KnownInputs {
+    programInfo;
+    config;
+    /**
+     * Known inputs from the whole program.
+     */
+    knownInputIds = new Map();
+    /** Known container classes of inputs. */
+    _allClasses = new Set();
+    /** Maps classes to their directive info. */
+    _classToDirectiveInfo = new Map();
     constructor(programInfo, config) {
         this.programInfo = programInfo;
         this.config = config;
-        /**
-         * Known inputs from the whole program.
-         */
-        this.knownInputIds = new Map();
-        /** Known container classes of inputs. */
-        this._allClasses = new Set();
-        /** Maps classes to their directive info. */
-        this._classToDirectiveInfo = new Map();
     }
     /** Whether the given input exists. */
     has(descr) {
@@ -274,7 +186,7 @@ class KnownInputs {
         }
         const directiveInfo = this._classToDirectiveInfo.get(data.node.parent);
         const inputInfo = {
-            file: group_replacements.projectFile(data.node.getSourceFile(), this.programInfo),
+            file: combine_units.projectFile(data.node.getSourceFile(), this.programInfo),
             metadata: data.metadata,
             descriptor: data.descriptor,
             container: directiveInfo,
@@ -300,8 +212,8 @@ class KnownInputs {
         const inputInfo = this.knownInputIds.get(input.key);
         const existingIncompatibility = inputInfo.container.getInputMemberIncompatibility(input);
         // Ensure an existing more significant incompatibility is not overridden.
-        if (existingIncompatibility !== null && group_replacements.isInputMemberIncompatibility(existingIncompatibility)) {
-            incompatibility = group_replacements.pickInputIncompatibility(existingIncompatibility, incompatibility);
+        if (existingIncompatibility !== null && migrate_ts_type_references.isFieldIncompatibility(existingIncompatibility)) {
+            incompatibility = migrate_ts_type_references.pickFieldIncompatibility(existingIncompatibility, incompatibility);
         }
         this.knownInputIds
             .get(input.key)
@@ -329,13 +241,13 @@ class KnownInputs {
     captureUnknownDerivedField(field) {
         this.markFieldIncompatible(field, {
             context: null,
-            reason: group_replacements.InputIncompatibilityReason.OverriddenByDerivedClass,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.OverriddenByDerivedClass,
         });
     }
     captureUnknownParentField(field) {
         this.markFieldIncompatible(field, {
             context: null,
-            reason: group_replacements.InputIncompatibilityReason.TypeConflictWithBaseClass,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.TypeConflictWithBaseClass,
         });
     }
 }
@@ -391,17 +303,15 @@ function prepareAnalysisInfo(userProgram, compiler, programAbsoluteRootPaths) {
  *    - imports that may need to be updated.
  */
 class MigrationResult {
-    constructor() {
-        this.printer = ts__default["default"].createPrinter({ newLine: ts__default["default"].NewLineKind.LineFeed });
-        // May be `null` if the input cannot be converted. This is also
-        // signified by an incompatibility- but the input is tracked here as it
-        // still is a "source input".
-        this.sourceInputs = new Map();
-        this.references = [];
-        // Execution data
-        this.replacements = [];
-        this.inputDecoratorSpecifiers = new Map();
-    }
+    printer = ts__default["default"].createPrinter({ newLine: ts__default["default"].NewLineKind.LineFeed });
+    // May be `null` if the input cannot be converted. This is also
+    // signified by an incompatibility- but the input is tracked here as it
+    // still is a "source input".
+    sourceInputs = new Map();
+    references = [];
+    // Execution data
+    replacements = [];
+    inputDecoratorSpecifiers = new Map();
 }
 
 /** Attempts to extract metadata of a potential TypeScript `@Input()` declaration. */
@@ -414,7 +324,7 @@ function extractDecoratorInput(node, host, reflector, metadataReader, evaluator,
  * part of a `.d.ts` file.
  */
 function extractDtsInput(node, metadataReader) {
-    if (!group_replacements.isInputContainerNode(node) ||
+    if (!combine_units.isInputContainerNode(node) ||
         !ts__default["default"].isIdentifier(node.name) ||
         !node.getSourceFile().isDeclarationFile) {
         return null;
@@ -425,7 +335,18 @@ function extractDtsInput(node, metadataReader) {
         !ts__default["default"].isIdentifier(node.parent.name)) {
         return null;
     }
-    const directiveMetadata = metadataReader.getDirectiveMetadata(new checker.Reference(node.parent));
+    let directiveMetadata = null;
+    // Getting directive metadata can throw errors when e.g. types referenced
+    // in the `.d.ts` aren't resolvable. This seems to be unexpected and shouldn't
+    // result in the entire migration to be failing.
+    try {
+        directiveMetadata = metadataReader.getDirectiveMetadata(new checker.Reference(node.parent));
+    }
+    catch (e) {
+        console.error('Unexpected error. Gracefully ignoring.');
+        console.error('Could not parse directive metadata:', e);
+        return null;
+    }
     const inputMapping = directiveMetadata?.inputs.getByClassPropertyName(node.name.text);
     // Signal inputs are never tracked and migrated.
     if (inputMapping?.isSignal) {
@@ -437,6 +358,8 @@ function extractDtsInput(node, metadataReader) {
             ...inputMapping,
             inputDecorator: null,
             inSourceFile: false,
+            // Inputs from `.d.ts` cannot have any field decorators applied.
+            fieldDecorators: [],
         };
 }
 /**
@@ -444,7 +367,7 @@ function extractDtsInput(node, metadataReader) {
  * directly defined inside a source file (`.ts`).
  */
 function extractSourceCodeInput(node, host, reflector, evaluator, refEmitter) {
-    if (!group_replacements.isInputContainerNode(node) ||
+    if (!combine_units.isInputContainerNode(node) ||
         !ts__default["default"].isIdentifier(node.name) ||
         node.getSourceFile().isDeclarationFile) {
         return null;
@@ -488,6 +411,7 @@ function extractSourceCodeInput(node, host, reflector, evaluator, refEmitter) {
         inSourceFile: true,
         transform: transformResult,
         inputDecorator,
+        fieldDecorators: decorators,
     };
 }
 /**
@@ -527,14 +451,19 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
     if (ts__default["default"].isAccessor(node)) {
         return {
             context: node,
-            reason: group_replacements.InputIncompatibilityReason.Accessor,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.Accessor,
         };
     }
     assert__default["default"](metadata.inputDecorator !== null, 'Expected an input decorator for inputs that are being migrated.');
     let initialValue = node.initializer;
     let isUndefinedInitialValue = node.initializer === undefined ||
         (ts__default["default"].isIdentifier(node.initializer) && node.initializer.text === 'undefined');
-    const loosePropertyInitializationWithStrictNullChecks = options.strict !== true && options.strictPropertyInitialization !== true;
+    const strictNullChecksEnabled = options.strict === true || options.strictNullChecks === true;
+    const strictPropertyInitialization = options.strict === true || options.strictPropertyInitialization === true;
+    // Shorthand should never be used, as would expand the type of `T` to be `T|undefined`.
+    // This wouldn't matter with strict null checks disabled, but it can break if this is
+    // a library that is later consumed with strict null checks enabled.
+    const avoidTypeExpansion = !strictNullChecksEnabled;
     // If an input can be required, due to the non-null assertion on the property,
     // make it required if there is no initializer.
     if (node.exclamationToken !== undefined && initialValue === undefined) {
@@ -548,7 +477,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
     if (!metadata.required &&
         node.type !== undefined &&
         isUndefinedInitialValue &&
-        !loosePropertyInitializationWithStrictNullChecks) {
+        !avoidTypeExpansion) {
         preferShorthandIfPossible = { originalType: node.type };
     }
     // If the input is using `@Input() bla?: string;` with the "optional question mark",
@@ -566,7 +495,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
         if (typeToAdd === undefined) {
             return {
                 context: node,
-                reason: group_replacements.InputIncompatibilityReason.InputWithQuestionMarkButNoGoodExplicitTypeExtractable,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable,
             };
         }
         if (!checker.isTypeAssignableTo(checker.getUndefinedType(), checker.getTypeFromTypeNode(typeToAdd))) {
@@ -581,8 +510,8 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
     // is disabled, while strict null checks are enabled; then we know that `undefined`
     // cannot be used as initial value, nor do we want to expand the input's type magically.
     // Instead, we detect this case and migrate to `undefined!` which leaves the behavior unchanged.
-    // TODO: This would be a good spot for a clean-up TODO.
-    if (loosePropertyInitializationWithStrictNullChecks &&
+    if (strictNullChecksEnabled &&
+        !strictPropertyInitialization &&
         node.initializer === undefined &&
         node.type !== undefined &&
         node.questionToken === undefined &&
@@ -607,7 +536,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
             // the generated type might depend on imports that we cannot add here (nor want).
             return {
                 context: node,
-                reason: group_replacements.InputIncompatibilityReason.RequiredInputButNoGoodExplicitTypeExtractable,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SignalInput__RequiredButNoGoodExplicitTypeExtractable,
             };
         }
     }
@@ -659,7 +588,7 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
     const visitor = (node) => {
         const decoratorInput = extractDecoratorInput(node, host, reflector, dtsMetadataReader, evaluator, refEmitter);
         if (decoratorInput !== null) {
-            assert__default["default"](group_replacements.isInputContainerNode(node), 'Expected input to be declared on accessor or property.');
+            assert__default["default"](combine_units.isInputContainerNode(node), 'Expected input to be declared on accessor or property.');
             const inputDescr = getInputDescriptor(host, node);
             // track all inputs, even from declarations for reference resolution.
             knownDecoratorInputs.register({ descriptor: inputDescr, metadata: decoratorInput, node });
@@ -667,7 +596,7 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
             // these are then later migrated in the migration phase.
             if (decoratorInput.inSourceFile && host.isSourceFileForCurrentMigration(sf)) {
                 const conversionPreparation = prepareAndCheckForConversion(node, decoratorInput, checker, host.compilerOptions);
-                if (group_replacements.isInputMemberIncompatibility(conversionPreparation)) {
+                if (migrate_ts_type_references.isFieldIncompatibility(conversionPreparation)) {
                     knownDecoratorInputs.markFieldIncompatible(inputDescr, conversionPreparation);
                     result.sourceInputs.set(inputDescr, null);
                 }
@@ -706,8 +635,17 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
  * In addition, spying onto an input may be problematic- so we skip migrating
  * such.
  */
-function pass3__checkIncompatiblePatterns(inheritanceGraph, checker, groupedTsAstVisitor, knownInputs) {
-    group_replacements.checkIncompatiblePatterns(inheritanceGraph, checker, groupedTsAstVisitor, knownInputs, () => knownInputs.getAllInputContainingClasses());
+function pass3__checkIncompatiblePatterns(host, inheritanceGraph, checker$1, groupedTsAstVisitor, knownInputs) {
+    migrate_ts_type_references.checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedTsAstVisitor, knownInputs, () => knownInputs.getAllInputContainingClasses());
+    for (const input of knownInputs.knownInputIds.values()) {
+        const hostBindingDecorators = checker.getAngularDecorators(input.metadata.fieldDecorators, ['HostBinding'], host.isMigratingCore);
+        if (hostBindingDecorators.length > 0) {
+            knownInputs.markFieldIncompatible(input.descriptor, {
+                context: hostBindingDecorators[0].node,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SignalIncompatibleWithHostBinding,
+            });
+        }
+    }
 }
 
 /**
@@ -721,7 +659,7 @@ function pass3__checkIncompatiblePatterns(inheritanceGraph, checker, groupedTsAs
  * such.
  */
 function pass2_IdentifySourceFileReferences(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, groupedTsAstVisitor, knownInputs, result, fieldNamesToConsiderForReferenceLookup) {
-    groupedTsAstVisitor.register(group_replacements.createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownInputs, fieldNamesToConsiderForReferenceLookup, result).visitor);
+    groupedTsAstVisitor.register(combine_units.createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownInputs, fieldNamesToConsiderForReferenceLookup, result).visitor);
 }
 
 /**
@@ -749,26 +687,26 @@ function executeAnalysisPhase(host, knownInputs, result, { sourceFiles, fullProg
     }
     // A graph starting with source files is sufficient. We will resolve into
     // declaration files if a source file depends on such.
-    const inheritanceGraph = new group_replacements.InheritanceGraph(typeChecker).expensivePopulate(sourceFiles);
-    const pass2And3SourceFileVisitor = new group_replacements.GroupedTsAstVisitor(sourceFiles);
+    const inheritanceGraph = new migrate_ts_type_references.InheritanceGraph(typeChecker).expensivePopulate(sourceFiles);
+    const pass2And3SourceFileVisitor = new migrate_ts_type_references.GroupedTsAstVisitor(sourceFiles);
     // Register pass 2. Find all source file references.
     pass2_IdentifySourceFileReferences(host.programInfo, typeChecker, reflector, resourceLoader, evaluator, templateTypeChecker, pass2And3SourceFileVisitor, knownInputs, result, fieldNamesToConsiderForReferenceLookup);
     // Register pass 3. Check incompatible patterns pass.
-    pass3__checkIncompatiblePatterns(inheritanceGraph, typeChecker, pass2And3SourceFileVisitor, knownInputs);
+    pass3__checkIncompatiblePatterns(host, inheritanceGraph, typeChecker, pass2And3SourceFileVisitor, knownInputs);
     // Perform Pass 2 and Pass 3, efficiently in one pass.
     pass2And3SourceFileVisitor.execute();
     // Determine incompatible inputs based on resolved references.
     for (const reference of result.references) {
-        if (group_replacements.isTsReference(reference) && reference.from.isWrite) {
+        if (combine_units.isTsReference(reference) && reference.from.isWrite) {
             knownInputs.markFieldIncompatible(reference.target, {
-                reason: group_replacements.InputIncompatibilityReason.WriteAssignment,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.WriteAssignment,
                 context: reference.from.node,
             });
         }
-        if (group_replacements.isTemplateReference(reference) || group_replacements.isHostBindingReference(reference)) {
+        if (combine_units.isTemplateReference(reference) || combine_units.isHostBindingReference(reference)) {
             if (reference.from.isWrite) {
                 knownInputs.markFieldIncompatible(reference.target, {
-                    reason: group_replacements.InputIncompatibilityReason.WriteAssignment,
+                    reason: migrate_ts_type_references.FieldIncompatibilityReason.WriteAssignment,
                     // No TS node context available for template or host bindings.
                     context: null,
                 });
@@ -776,10 +714,10 @@ function executeAnalysisPhase(host, knownInputs, result, { sourceFiles, fullProg
         }
         // TODO: Remove this when we support signal narrowing in templates.
         // https://github.com/angular/angular/pull/55456.
-        if (group_replacements.isTemplateReference(reference)) {
+        if (combine_units.isTemplateReference(reference)) {
             if (reference.from.isLikelyPartOfNarrowing) {
                 knownInputs.markFieldIncompatible(reference.target, {
-                    reason: group_replacements.InputIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet,
+                    reason: migrate_ts_type_references.FieldIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet,
                     context: null,
                 });
             }
@@ -809,7 +747,7 @@ function executeAnalysisPhase(host, knownInputs, result, { sourceFiles, fullProg
  * would then have other derived classes as well, it would propagate the status.
  */
 function pass4__checkInheritanceOfInputs(inheritanceGraph, metaRegistry, knownInputs) {
-    group_replacements.checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, knownInputs, {
+    migrate_ts_type_references.checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, knownInputs, {
         isClassWithKnownFields: (clazz) => knownInputs.isInputContainingClass(clazz),
         getFieldsForClass: (clazz) => {
             const directiveInfo = knownInputs.getDirectiveInfoForClass(clazz);
@@ -885,25 +823,15 @@ function topologicalSort(graph) {
 }
 
 /** Merges a list of compilation units into a combined unit. */
-function mergeCompilationUnitData(metadataFiles) {
+function combineCompilationUnitData(unitA, unitB) {
     const result = {
         knownInputs: {},
     };
-    const idToGraphNode = new Map();
-    const inheritanceGraph = [];
-    const isNodeIncompatible = (node) => node.info.memberIncompatibility !== null || node.info.owningClassIncompatibility !== null;
-    for (const file of metadataFiles) {
+    for (const file of [unitA, unitB]) {
         for (const [key, info] of Object.entries(file.knownInputs)) {
             const existing = result.knownInputs[key];
             if (existing === undefined) {
                 result.knownInputs[key] = info;
-                const node = {
-                    incoming: new Set(),
-                    outgoing: new Set(),
-                    data: { info, key },
-                };
-                inheritanceGraph.push(node);
-                idToGraphNode.set(key, node);
                 continue;
             }
             // Merge metadata.
@@ -921,7 +849,7 @@ function mergeCompilationUnitData(metadataFiles) {
                 else {
                     // Input might not be incompatible in one target, but others might invalidate it.
                     // merge the incompatibility state.
-                    existing.memberIncompatibility = group_replacements.pickInputIncompatibility({ reason: info.memberIncompatibility, context: null }, { reason: existing.memberIncompatibility, context: null }).reason;
+                    existing.memberIncompatibility = migrate_ts_type_references.pickFieldIncompatibility({ reason: info.memberIncompatibility, context: null }, { reason: existing.memberIncompatibility, context: null }).reason;
                 }
             }
             // Merge incompatibility of the class owning the input.
@@ -933,7 +861,30 @@ function mergeCompilationUnitData(metadataFiles) {
             }
         }
     }
-    for (const [key, info] of Object.entries(result.knownInputs)) {
+    return result;
+}
+function convertToGlobalMeta(combinedData) {
+    const globalMeta = {
+        knownInputs: {},
+    };
+    const idToGraphNode = new Map();
+    const inheritanceGraph = [];
+    const isNodeIncompatible = (node) => node.info.memberIncompatibility !== null || node.info.owningClassIncompatibility !== null;
+    for (const [key, info] of Object.entries(combinedData.knownInputs)) {
+        const existing = globalMeta.knownInputs[key];
+        if (existing !== undefined) {
+            continue;
+        }
+        const node = {
+            incoming: new Set(),
+            outgoing: new Set(),
+            data: { info, key },
+        };
+        inheritanceGraph.push(node);
+        idToGraphNode.set(key, node);
+        globalMeta.knownInputs[key] = info;
+    }
+    for (const [key, info] of Object.entries(globalMeta.knownInputs)) {
         if (info.extendsFrom !== null) {
             const from = idToGraphNode.get(key);
             const target = idToGraphNode.get(info.extendsFrom);
@@ -953,22 +904,22 @@ function mergeCompilationUnitData(metadataFiles) {
             // If parent is incompatible and not migrated, then this input
             // cannot be migrated either. Try propagating parent incompatibility then.
             if (isNodeIncompatible(parent.data)) {
-                node.data.info.memberIncompatibility = group_replacements.pickInputIncompatibility({ reason: group_replacements.InputIncompatibilityReason.ParentIsIncompatible, context: null }, existingMemberIncompatibility).reason;
+                node.data.info.memberIncompatibility = migrate_ts_type_references.pickFieldIncompatibility({ reason: migrate_ts_type_references.FieldIncompatibilityReason.ParentIsIncompatible, context: null }, existingMemberIncompatibility).reason;
                 break;
             }
         }
     }
-    for (const info of Object.values(result.knownInputs)) {
+    for (const info of Object.values(combinedData.knownInputs)) {
         // We never saw a source file for this input, globally. Try marking it as incompatible,
         // so that all references and inheritance checks can propagate accordingly.
         if (!info.seenAsSourceInput) {
             const existingMemberIncompatibility = info.memberIncompatibility !== null
                 ? { reason: info.memberIncompatibility, context: null }
                 : null;
-            info.memberIncompatibility = group_replacements.pickInputIncompatibility({ reason: group_replacements.InputIncompatibilityReason.OutsideOfMigrationScope, context: null }, existingMemberIncompatibility).reason;
+            info.memberIncompatibility = migrate_ts_type_references.pickFieldIncompatibility({ reason: migrate_ts_type_references.FieldIncompatibilityReason.OutsideOfMigrationScope, context: null }, existingMemberIncompatibility).reason;
         }
     }
-    return result;
+    return globalMeta;
 }
 
 function populateKnownInputsFromGlobalData(knownInputs, globalData) {
@@ -992,46 +943,6 @@ function populateKnownInputsFromGlobalData(knownInputs, globalData) {
     }
 }
 
-/**
- * Inserts a leading string for the given node, respecting
- * indentation of the given anchor node.
- *
- * Useful for inserting TODOs.
- */
-function insertPrecedingLine(node, info, text) {
-    const leadingSpace = leading_space.getLeadingLineWhitespaceOfNode(node);
-    return new group_replacements.Replacement(group_replacements.projectFile(node.getSourceFile(), info), new group_replacements.TextUpdate({
-        position: node.getStart(),
-        end: node.getStart(),
-        toInsert: `${text}\n${leadingSpace}`,
-    }));
-}
-
-/**
- * Cuts the given string into lines basing around the specified
- * line length limit. This function breaks the string on a per-word basis.
- */
-function cutStringToLineLimit(str, limit) {
-    const words = str.split(' ');
-    const chunks = [];
-    let chunkIdx = 0;
-    while (words.length) {
-        // New line if we exceed limit.
-        if (chunks[chunkIdx] !== undefined && chunks[chunkIdx].length > limit) {
-            chunkIdx++;
-        }
-        // Ensure line is initialized for the given index.
-        if (chunks[chunkIdx] === undefined) {
-            chunks[chunkIdx] = '';
-        }
-        const word = words.shift();
-        const needsSpace = chunks[chunkIdx].length > 0;
-        // Insert word. Add space before, if the line already contains text.
-        chunks[chunkIdx] += `${needsSpace ? ' ' : ''}${word}`;
-    }
-    return chunks;
-}
-
 // TODO: Consider initializations inside the constructor. Those are not migrated right now
 // though, as they are writes.
 /**
@@ -1073,7 +984,7 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
             // When using the `input()` shorthand, try cutting of `undefined` from potential
             // union types. `undefined` will be automatically included in the type.
             if (ts__default["default"].isUnionTypeNode(resolvedType)) {
-                resolvedType = group_replacements.removeFromUnionIfPossible(resolvedType, (t) => t.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
+                resolvedType = migrate_ts_type_references.removeFromUnionIfPossible(resolvedType, (t) => t.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
             }
         }
     }
@@ -1113,9 +1024,9 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
     const newPropertyText = result.printer.printNode(ts__default["default"].EmitHint.Unspecified, newNode, node.getSourceFile());
     const replacements = [];
     if (leadingTodoText !== null) {
-        replacements.push(insertPrecedingLine(node, info, '// TODO: Notes from signal input migration:'), ...cutStringToLineLimit(leadingTodoText, 70).map((line) => insertPrecedingLine(node, info, `//  ${line}`)));
+        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 group_replacements.Replacement(group_replacements.projectFile(node.getSourceFile(), info), new group_replacements.TextUpdate({
+    replacements.push(new combine_units.Replacement(combine_units.projectFile(node.getSourceFile(), info), new combine_units.TextUpdate({
         position: node.getStart(),
         end: node.getEnd(),
         toInsert: newPropertyText,
@@ -1154,32 +1065,6 @@ function extractTransformOfInput(transform, resolvedType, checker) {
     };
 }
 
-/**
- * Inserts a TODO for the incompatibility blocking the given node
- * from being migrated.
- */
-function insertTodoForIncompatibility(node, programInfo, input) {
-    const incompatibility = input.container.getInputMemberIncompatibility(input.descriptor);
-    if (incompatibility === null) {
-        return [];
-    }
-    // If an input is skipped via config filter or outside migration scope, do not
-    // insert TODOs, as this could results in lots of unnecessary comments.
-    if (group_replacements.isInputMemberIncompatibility(incompatibility) &&
-        (incompatibility.reason === group_replacements.InputIncompatibilityReason.SkippedViaConfigFilter ||
-            incompatibility.reason === group_replacements.InputIncompatibilityReason.OutsideOfMigrationScope)) {
-        return [];
-    }
-    const message = group_replacements.isInputMemberIncompatibility(incompatibility)
-        ? getMessageForInputIncompatibility(incompatibility.reason).short
-        : getMessageForClassIncompatibility(incompatibility).short;
-    const lines = cutStringToLineLimit(message, 70);
-    return [
-        insertPrecedingLine(node, programInfo, `// TODO: Skipped for migration because:`),
-        ...lines.map((line) => insertPrecedingLine(node, programInfo, `//  ${line}`)),
-    ];
-}
-
 /**
  * Phase that migrates `@Input()` declarations to signal inputs and
  * manages imports within the given file.
@@ -1192,9 +1077,13 @@ function pass6__migrateInputDeclarations(host, checker, result, knownInputs, imp
         const inputInfo = knownInputs.get(input);
         // Do not migrate incompatible inputs.
         if (inputInfo.isIncompatible()) {
+            const incompatibilityReason = inputInfo.container.getInputMemberIncompatibility(input);
             // Add a TODO for the incompatible input, if desired.
-            if (host.config.insertTodosForSkippedFields) {
-                result.replacements.push(...insertTodoForIncompatibility(input.node, info, inputInfo));
+            if (incompatibilityReason !== null && host.config.insertTodosForSkippedFields) {
+                result.replacements.push(...migrate_ts_type_references.insertTodoForIncompatibility(input.node, info, incompatibilityReason, {
+                    single: 'input',
+                    plural: 'inputs',
+                }));
             }
             filesWithIncompatibleInputs.add(sf);
             continue;
@@ -1217,7 +1106,7 @@ function pass6__migrateInputDeclarations(host, checker, result, knownInputs, imp
  * previous migrate phases.
  */
 function pass10_applyImportManager(importManager, result, sourceFiles, info) {
-    group_replacements.applyImportManagerChanges(importManager, result.replacements, sourceFiles, info);
+    combine_units.applyImportManagerChanges(importManager, result.replacements, sourceFiles, info);
 }
 
 /**
@@ -1227,7 +1116,7 @@ function pass10_applyImportManager(importManager, result, sourceFiles, info) {
  * where needed to ensure narrowing continues to work. E.g.
  */
 function pass5__migrateTypeScriptReferences(host, references, checker, info) {
-    group_replacements.migrateTypeScriptReferences(host, references, checker, info);
+    migrate_ts_type_references.migrateTypeScriptReferences(host, references, checker, info);
 }
 
 /**
@@ -1238,7 +1127,7 @@ function pass7__migrateTemplateReferences(host, references) {
     const seenFileReferences = new Set();
     for (const reference of references) {
         // This pass only deals with HTML template references.
-        if (!group_replacements.isTemplateReference(reference)) {
+        if (!combine_units.isTemplateReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -1255,7 +1144,7 @@ function pass7__migrateTemplateReferences(host, references) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new group_replacements.Replacement(reference.from.templateFile, new group_replacements.TextUpdate({
+        host.replacements.push(new combine_units.Replacement(reference.from.templateFile, new combine_units.TextUpdate({
             position: reference.from.read.sourceSpan.end,
             end: reference.from.read.sourceSpan.end,
             toInsert: appendText,
@@ -1271,7 +1160,7 @@ function pass8__migrateHostBindings(host, references, info) {
     const seenReferences = new WeakMap();
     for (const reference of references) {
         // This pass only deals with host binding references.
-        if (!group_replacements.isHostBindingReference(reference)) {
+        if (!combine_units.isHostBindingReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -1295,7 +1184,7 @@ function pass8__migrateHostBindings(host, references, info) {
         const appendText = reference.from.isObjectShorthandExpression
             ? `: ${reference.from.read.name}()`
             : `()`;
-        host.replacements.push(new group_replacements.Replacement(group_replacements.projectFile(bindingField.getSourceFile(), info), new group_replacements.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
+        host.replacements.push(new combine_units.Replacement(combine_units.projectFile(bindingField.getSourceFile(), info), new combine_units.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
     }
 }
 
@@ -1306,43 +1195,7 @@ function pass8__migrateHostBindings(host, references, info) {
       in Catalyst test files.
  */
 function pass9__migrateTypeScriptTypeReferences(host, references, importManager, info) {
-    const seenTypeNodes = new WeakSet();
-    for (const reference of references) {
-        // This pass only deals with TS input class type references.
-        if (!group_replacements.isTsClassTypeReference(reference)) {
-            continue;
-        }
-        // Skip references to classes that are not fully migrated.
-        if (!host.shouldMigrateReferencesToClass(reference.target)) {
-            continue;
-        }
-        // Skip duplicate references. E.g. in batching.
-        if (seenTypeNodes.has(reference.from.node)) {
-            continue;
-        }
-        seenTypeNodes.add(reference.from.node);
-        if (reference.isPartialReference && reference.isPartOfCatalystFile) {
-            assert__default["default"](reference.from.node.typeArguments, 'Expected type arguments for partial reference.');
-            assert__default["default"](reference.from.node.typeArguments.length === 1, 'Expected an argument for reference.');
-            const firstArg = reference.from.node.typeArguments[0];
-            const sf = firstArg.getSourceFile();
-            // Naive detection of the import. Sufficient for this test file migration.
-            const catalystImport = sf.text.includes('google3/javascript/angular2/testing/catalyst/fake_async')
-                ? 'google3/javascript/angular2/testing/catalyst/fake_async'
-                : 'google3/javascript/angular2/testing/catalyst/async';
-            const unwrapImportExpr = importManager.addImport({
-                exportModuleSpecifier: catalystImport,
-                exportSymbolName: 'UnwrapSignalInputs',
-                requestedFile: sf,
-            });
-            host.replacements.push(new group_replacements.Replacement(group_replacements.projectFile(sf, info), new group_replacements.TextUpdate({
-                position: firstArg.getStart(),
-                end: firstArg.getStart(),
-                toInsert: `${host.printer.printNode(ts__default["default"].EmitHint.Unspecified, unwrapImportExpr, sf)}<`,
-            })));
-            host.replacements.push(new group_replacements.Replacement(group_replacements.projectFile(sf, info), new group_replacements.TextUpdate({ position: firstArg.getEnd(), end: firstArg.getEnd(), toInsert: '>' })));
-        }
-    }
+    migrate_ts_type_references.migrateTypeScriptTypeReferences(host, references, importManager, info);
 }
 
 /**
@@ -1366,7 +1219,7 @@ function executeMigrationPhase(host, knownInputs, result, info) {
         replacements: result.replacements,
         shouldMigrateReferencesToField: (inputDescr) => knownInputs.has(inputDescr) && knownInputs.get(inputDescr).isIncompatible() === false,
         shouldMigrateReferencesToClass: (clazz) => knownInputs.getDirectiveInfoForClass(clazz) !== undefined &&
-            knownInputs.getDirectiveInfoForClass(clazz).hasIncompatibleMembers() === false,
+            knownInputs.getDirectiveInfoForClass(clazz).hasMigratedFields(),
     };
     // Migrate passes.
     pass5__migrateTypeScriptReferences(referenceMigrationHost, result.references, typeChecker, info);
@@ -1377,24 +1230,13 @@ function executeMigrationPhase(host, knownInputs, result, info) {
     pass10_applyImportManager(importManager, result, sourceFiles, info);
 }
 
-/** Input reasons that cannot be ignored. */
-const nonIgnorableInputIncompatibilities = [
-    // Outside of scope inputs should not be migrated. E.g. references to inputs in `node_modules/`.
-    group_replacements.InputIncompatibilityReason.OutsideOfMigrationScope,
-    // Explicitly filtered inputs cannot be skipped via best effort mode.
-    group_replacements.InputIncompatibilityReason.SkippedViaConfigFilter,
-    // There is no good output for accessor inputs.
-    group_replacements.InputIncompatibilityReason.Accessor,
-    // There is no good output for such inputs. We can't perform "conversion".
-    group_replacements.InputIncompatibilityReason.RequiredInputButNoGoodExplicitTypeExtractable,
-];
 /** Filters ignorable input incompatibilities when best effort mode is enabled. */
 function filterIncompatibilitiesForBestEffortMode(knownInputs) {
     knownInputs.knownInputIds.forEach(({ container: c }) => {
         // All class incompatibilities are "filterable" right now.
         c.incompatible = null;
         for (const [key, i] of c.memberIncompatibility.entries()) {
-            if (!nonIgnorableInputIncompatibilities.includes(i.reason)) {
+            if (!migrate_ts_type_references.nonIgnorableFieldIncompatibilities.includes(i.reason)) {
                 c.memberIncompatibility.delete(key);
             }
         }
@@ -1405,15 +1247,16 @@ function filterIncompatibilitiesForBestEffortMode(knownInputs) {
  * Tsurge migration for migrating Angular `@Input()` declarations to
  * signal inputs, with support for batch execution.
  */
-class SignalInputMigration extends group_replacements.TsurgeComplexMigration {
+class SignalInputMigration extends combine_units.TsurgeComplexMigration {
+    config;
+    upgradedAnalysisPhaseResults = null;
     constructor(config = {}) {
         super();
         this.config = config;
-        this.upgradedAnalysisPhaseResults = null;
     }
     // Override the default ngtsc program creation, to add extra flags.
     createProgram(tsconfigAbsPath, fs) {
-        return group_replacements.createNgtscProgram(tsconfigAbsPath, fs, {
+        return combine_units.createNgtscProgram(tsconfigAbsPath, fs, {
             _compilePoisonedComponents: true,
             // We want to migrate non-exported classes too.
             compileNonExportedClasses: true,
@@ -1471,8 +1314,8 @@ class SignalInputMigration extends group_replacements.TsurgeComplexMigration {
         const unitData = getCompilationUnitMetadata(knownInputs);
         // Non-batch mode!
         if (this.config.upgradeAnalysisPhaseToAvoidBatch) {
-            const merged = await this.merge([unitData]);
-            const replacements = await this.migrate(merged, info, {
+            const globalMeta = await this.globalMeta(unitData);
+            const { replacements } = await this.migrate(globalMeta, info, {
                 knownInputs,
                 result,
                 host,
@@ -1486,10 +1329,13 @@ class SignalInputMigration extends group_replacements.TsurgeComplexMigration {
                 knownInputs,
             };
         }
-        return group_replacements.confirmAsSerializable(unitData);
+        return combine_units.confirmAsSerializable(unitData);
+    }
+    async combine(unitA, unitB) {
+        return combine_units.confirmAsSerializable(combineCompilationUnitData(unitA, unitB));
     }
-    async merge(units) {
-        return group_replacements.confirmAsSerializable(mergeCompilationUnitData(units));
+    async globalMeta(combinedData) {
+        return combine_units.confirmAsSerializable(convertToGlobalMeta(combinedData));
     }
     async migrate(globalMetadata, info, nonBatchData) {
         const knownInputs = nonBatchData?.knownInputs ?? new KnownInputs(info, this.config);
@@ -1507,7 +1353,7 @@ class SignalInputMigration extends group_replacements.TsurgeComplexMigration {
         }
         this.config.reportProgressFn?.(60, 'Collecting migration changes..');
         executeMigrationPhase(host, knownInputs, result, analysisDeps);
-        return result.replacements;
+        return { replacements: result.replacements };
     }
     async stats(globalMetadata) {
         let fullCompilationInputs = 0;
@@ -1517,20 +1363,26 @@ class SignalInputMigration extends group_replacements.TsurgeComplexMigration {
         const classIncompatibleCounts = {};
         for (const [id, input] of Object.entries(globalMetadata.knownInputs)) {
             fullCompilationInputs++;
-            if (input.seenAsSourceInput) {
-                sourceInputs++;
+            const isConsideredSourceInput = input.seenAsSourceInput &&
+                input.memberIncompatibility !== migrate_ts_type_references.FieldIncompatibilityReason.OutsideOfMigrationScope &&
+                input.memberIncompatibility !== migrate_ts_type_references.FieldIncompatibilityReason.SkippedViaConfigFilter;
+            // We won't track incompatibilities to inputs that aren't considered source inputs.
+            // Tracking their statistics wouldn't provide any value.
+            if (!isConsideredSourceInput) {
+                continue;
             }
+            sourceInputs++;
             if (input.memberIncompatibility !== null || input.owningClassIncompatibility !== null) {
                 incompatibleInputs++;
             }
             if (input.memberIncompatibility !== null) {
-                const reasonName = group_replacements.InputIncompatibilityReason[input.memberIncompatibility];
+                const reasonName = migrate_ts_type_references.FieldIncompatibilityReason[input.memberIncompatibility];
                 const key = `input-field-incompatibility-${reasonName}`;
                 fieldIncompatibleCounts[key] ??= 0;
                 fieldIncompatibleCounts[key]++;
             }
             if (input.owningClassIncompatibility !== null) {
-                const reasonName = group_replacements.ClassIncompatibilityReason[input.owningClassIncompatibility];
+                const reasonName = migrate_ts_type_references.ClassIncompatibilityReason[input.owningClassIncompatibility];
                 const key = `input-owning-class-incompatibility-${reasonName}`;
                 classIncompatibleCounts[key] ??= 0;
                 classIncompatibleCounts[key]++;
@@ -1562,19 +1414,10 @@ function filterInputsViaConfig(result, knownInputs, config) {
             skippedInputs.add(input.descriptor.key);
             knownInputs.markFieldIncompatible(input.descriptor, {
                 context: null,
-                reason: group_replacements.InputIncompatibilityReason.SkippedViaConfigFilter,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SkippedViaConfigFilter,
             });
         }
     }
-    result.references = result.references.filter((reference) => {
-        if (isInputDescriptor(reference.target)) {
-            // Only migrate the reference if the target is NOT skipped.
-            return !skippedInputs.has(reference.target.key);
-        }
-        // Class references may be migrated. This is up to the logic handling
-        // the class reference. E.g. it may not migrate if any member is incompatible.
-        return true;
-    });
 }
 function createMigrationHost(info, config) {
     return new MigrationHost(/* isMigratingCore */ false, info, config, info.sourceFiles);
@@ -1586,7 +1429,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 group_replacements.DevkitMigrationFilesystem(tree);
+        const fs = new combine_units.DevkitMigrationFilesystem(tree);
         checker.setFileSystem(fs);
         const migration = new SignalInputMigration({
             bestEffortMode: options.bestEffortMode,
@@ -1618,12 +1461,17 @@ function migrate(options) {
         context.logger.info(``);
         context.logger.info(`Processing analysis data between targets..`);
         context.logger.info(``);
-        const merged = await migration.merge(unitResults);
+        const combined = await combine_units.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 { info, tsconfigPath } of programInfos) {
             context.logger.info(`Migrating: ${tsconfigPath}..`);
-            const replacements = await migration.migrate(merged, info);
-            const changesPerFile = group_replacements.groupReplacementsByFile(replacements);
+            const { replacements } = await migration.migrate(globalMeta, info);
+            const changesPerFile = combine_units.groupReplacementsByFile(replacements);
             for (const [file, changes] of changesPerFile) {
                 if (!replacementsPerFile.has(file)) {
                     replacementsPerFile.set(file, changes);
@@ -1640,7 +1488,7 @@ function migrate(options) {
             }
             tree.commitUpdate(recorder);
         }
-        const { counters } = await migration.stats(merged);
+        const { counters } = await migration.stats(globalMeta);
         const migratedInputs = counters.sourceInputs - counters.incompatibleInputs;
         context.logger.info('');
         context.logger.info(`Successfully migrated to signal inputs 🎉`);