@angular/core 19.0.0-next.10 → 19.0.0-next.11

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.10
+ * @license Angular v19.0.0-next.11
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10,19 +10,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var schematics = require('@angular-devkit/schematics');
 var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
-var group_replacements = require('./group_replacements-1f48eff7.js');
+var index = require('./index-f7b283e6.js');
 require('os');
 var ts = require('typescript');
-var checker = require('./checker-77660732.js');
-var program = require('./program-1413936a.js');
+var checker = require('./checker-51c08a1b.js');
+var program = require('./program-6e6520d8.js');
 var assert = require('assert');
 require('path');
+var migrate_ts_type_references = require('./migrate_ts_type_references-b2b55f62.js');
 require('@angular-devkit/core');
-require('./leading_space-d190b83b.js');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
+require('./leading_space-d190b83b.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -37,7 +38,7 @@ function 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 (!index.isHostBindingReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -61,7 +62,7 @@ function 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 index.Replacement(index.projectFile(bindingField.getSourceFile(), info), new index.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
     }
 }
 
@@ -73,7 +74,7 @@ function 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 (!index.isTemplateReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -90,7 +91,7 @@ function 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 index.Replacement(reference.from.templateFile, new index.TextUpdate({
             position: reference.from.read.sourceSpan.end,
             end: reference.from.read.sourceSpan.end,
             toInsert: appendText,
@@ -138,7 +139,7 @@ function extractQueryListType(node) {
  *       --> read stays
  *       --> emitDistinctChangesOnly is gone!
  */
-function computeReplacementsToMigrateQuery(node, metadata, importManager, info, printer) {
+function computeReplacementsToMigrateQuery(node, metadata, importManager, info, printer, options, checker$1) {
     const sf = node.getSourceFile();
     let newQueryFn = importManager.addImport({
         requestedFile: sf,
@@ -172,36 +173,56 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
     if (optionProperties.length > 0) {
         args.push(ts__default["default"].factory.createObjectLiteralExpression(optionProperties));
     }
-    // TODO: Can we consult, based on references and non-null assertions?
-    const isIndicatedAsRequired = node.exclamationToken !== undefined;
-    // If the query is required already via some indicators, and this is a "single"
-    // query, use the available `.required` method.
-    if (isIndicatedAsRequired && metadata.queryInfo.first) {
+    const strictNullChecksEnabled = options.strict === true || options.strictNullChecks === true;
+    const strictPropertyInitialization = options.strict === true || options.strictPropertyInitialization === true;
+    let isRequired = node.exclamationToken !== undefined;
+    // If we come across an application with strict null checks enabled, but strict
+    // property initialization is disabled, there are two options:
+    //   - Either the query is already typed to include `undefined` explicitly,
+    //     in which case an option query makes sense.
+    //   - OR, the query is not typed to include `undefined`. In which case, the query
+    //     should be marked as required to not break the app. The user-code throughout
+    //     the application (given strict null checks) already assumes non-nullable!
+    if (strictNullChecksEnabled &&
+        !strictPropertyInitialization &&
+        node.initializer === undefined &&
+        node.questionToken === undefined &&
+        type !== undefined &&
+        !checker$1.isTypeAssignableTo(checker$1.getUndefinedType(), checker$1.getTypeFromTypeNode(type))) {
+        isRequired = true;
+    }
+    if (isRequired && metadata.queryInfo.first) {
+        // If the query is required already via some indicators, and this is a "single"
+        // query, use the available `.required` method.
         newQueryFn = ts__default["default"].factory.createPropertyAccessExpression(newQueryFn, 'required');
     }
     // If this query is still nullable (i.e. not required), attempt to remove
     // explicit `undefined` types if possible.
-    if (!isIndicatedAsRequired && type !== undefined && ts__default["default"].isUnionTypeNode(type)) {
-        type = group_replacements.removeFromUnionIfPossible(type, (v) => v.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
+    if (!isRequired && type !== undefined && ts__default["default"].isUnionTypeNode(type)) {
+        type = migrate_ts_type_references.removeFromUnionIfPossible(type, (v) => v.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
     }
-    const locatorType = Array.isArray(metadata.queryInfo.predicate)
+    let locatorType = Array.isArray(metadata.queryInfo.predicate)
         ? null
         : metadata.queryInfo.predicate.expression;
-    const readType = metadata.queryInfo.read ?? locatorType;
-    // If the type and the read type are matching, we can rely on the TS generic
-    // signature rather than repeating e.g. `viewChild<Button>(Button)`.
+    let resolvedReadType = metadata.queryInfo.read ?? locatorType;
+    // If the original property type and the read type are matching, we can rely
+    // on the TS inference, instead of repeating types, like in `viewChild<Button>(Button)`.
     if (type !== undefined &&
-        readType instanceof checker.WrappedNodeExpr &&
-        ts__default["default"].isIdentifier(readType.node) &&
+        resolvedReadType instanceof checker.WrappedNodeExpr &&
+        ts__default["default"].isIdentifier(resolvedReadType.node) &&
         ts__default["default"].isTypeReferenceNode(type) &&
         ts__default["default"].isIdentifier(type.typeName) &&
-        type.typeName.text === readType.node.text) {
-        type = undefined;
-    }
-    const call = ts__default["default"].factory.createCallExpression(newQueryFn, type ? [type] : undefined, args);
+        type.typeName.text === resolvedReadType.node.text) {
+        locatorType = null;
+    }
+    const call = ts__default["default"].factory.createCallExpression(newQueryFn, 
+    // If there is no resolved `ReadT` (e.g. string predicate), we use the
+    // original type explicitly as generic. Otherwise, query API is smart
+    // enough to always infer.
+    resolvedReadType === null && type !== undefined ? [type] : undefined, args);
     const updated = ts__default["default"].factory.createPropertyDeclaration([ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword)], node.name, undefined, undefined, call);
     return [
-        new group_replacements.Replacement(group_replacements.projectFile(node.getSourceFile(), info), new group_replacements.TextUpdate({
+        new index.Replacement(index.projectFile(node.getSourceFile(), info), new index.TextUpdate({
             position: node.getStart(),
             end: node.getEnd(),
             toInsert: printer.printNode(ts__default["default"].EmitHint.Unspecified, updated, sf),
@@ -242,7 +263,7 @@ function getUniqueIDForClassProperty(property, info) {
     if (property.name === undefined) {
         return null;
     }
-    const id = group_replacements.projectFile(property.getSourceFile(), info).id.replace(/\.d\.ts$/, '.ts');
+    const id = index.projectFile(property.getSourceFile(), info).id.replace(/\.d\.ts$/, '.ts');
     // Note: If a class is nested, there could be an ID clash.
     // This is highly unlikely though, and this is not a problem because
     // in such cases, there is even less chance there are any references to
@@ -305,6 +326,7 @@ function extractSourceQueryDefinition(node, reflector, evaluator, info) {
         args: decorator.args ?? [],
         queryInfo,
         node: node,
+        fieldDecorators: decorators,
     };
 }
 
@@ -320,13 +342,13 @@ function markFieldIncompatibleInMetadata(data, id, reason) {
         existing.fieldReason = reason;
     }
     else {
-        existing.fieldReason = group_replacements.pickFieldIncompatibility({ reason, context: null }, { reason: existing.fieldReason, context: null }).reason;
+        existing.fieldReason = migrate_ts_type_references.pickFieldIncompatibility({ reason, context: null }, { reason: existing.fieldReason, context: null }).reason;
     }
 }
 function filterBestEffortIncompatibilities(knownQueries) {
     for (const query of Object.values(knownQueries.globalMetadata.problematicQueries)) {
         if (query.fieldReason !== null &&
-            !group_replacements.nonIgnorableFieldIncompatibilities.includes(query.fieldReason)) {
+            !migrate_ts_type_references.nonIgnorableFieldIncompatibilities.includes(query.fieldReason)) {
             query.fieldReason = null;
         }
     }
@@ -362,12 +384,12 @@ class KnownQueries {
         });
         this.knownQueryIDs.set(id, { key: id, node: queryField });
         const descriptor = { key: id, node: queryField };
-        const file = group_replacements.projectFile(queryField.getSourceFile(), this.info);
+        const file = index.projectFile(queryField.getSourceFile(), this.info);
         if (this.config.shouldMigrateQuery !== undefined &&
             !this.config.shouldMigrateQuery(descriptor, file)) {
             this.markFieldIncompatible(descriptor, {
                 context: null,
-                reason: group_replacements.FieldIncompatibilityReason.SkippedViaConfigFilter,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SkippedViaConfigFilter,
             });
         }
     }
@@ -398,27 +420,27 @@ class KnownQueries {
         if (this.isFieldIncompatible(parent) && !this.isFieldIncompatible(derived)) {
             this.markFieldIncompatible(derived, {
                 context: null,
-                reason: group_replacements.FieldIncompatibilityReason.ParentIsIncompatible,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.ParentIsIncompatible,
             });
             return;
         }
         if (this.isFieldIncompatible(derived) && !this.isFieldIncompatible(parent)) {
             this.markFieldIncompatible(parent, {
                 context: null,
-                reason: group_replacements.FieldIncompatibilityReason.DerivedIsIncompatible,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.DerivedIsIncompatible,
             });
         }
     }
     captureUnknownDerivedField(field) {
         this.markFieldIncompatible(field, {
             context: null,
-            reason: group_replacements.FieldIncompatibilityReason.OverriddenByDerivedClass,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.OverriddenByDerivedClass,
         });
     }
     captureUnknownParentField(field) {
         this.markFieldIncompatible(field, {
             context: null,
-            reason: group_replacements.FieldIncompatibilityReason.TypeConflictWithBaseClass,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.TypeConflictWithBaseClass,
         });
     }
     getIncompatibilityForField(descriptor) {
@@ -437,13 +459,13 @@ class KnownQueries {
     getIncompatibilityTextForField(field) {
         const incompatibilityInfo = this.globalMetadata.problematicQueries[field.key];
         if (incompatibilityInfo.fieldReason !== null) {
-            return group_replacements.getMessageForFieldIncompatibility(incompatibilityInfo.fieldReason, {
+            return migrate_ts_type_references.getMessageForFieldIncompatibility(incompatibilityInfo.fieldReason, {
                 single: 'query',
                 plural: 'queries',
             });
         }
         if (incompatibilityInfo.classReason !== null) {
-            return group_replacements.getMessageForClassIncompatibility(incompatibilityInfo.classReason, {
+            return migrate_ts_type_references.getMessageForClassIncompatibility(incompatibilityInfo.classReason, {
                 single: 'query',
                 plural: 'queries',
             });
@@ -476,7 +498,7 @@ function queryFunctionNameToDecorator(name) {
  * E.g. whether `<my-read>.toArray` is detected.
  */
 function checkTsReferenceAccessesField(ref, fieldName) {
-    const accessNode = group_replacements.traverseAccess(ref.from.node);
+    const accessNode = index.traverseAccess(ref.from.node);
     // Check if the reference is part of a property access.
     if (!ts__default["default"].isPropertyAccessExpression(accessNode.parent) ||
         !ts__default["default"].isIdentifier(accessNode.parent.name)) {
@@ -545,7 +567,7 @@ function checkNonTsReferenceCallsField(ref, fieldName) {
 }
 
 function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+    if (!index.isHostBindingReference(ref) && !index.isTemplateReference(ref) && !index.isTsReference(ref)) {
         return;
     }
     if (knownQueries.isFieldIncompatible(ref.target)) {
@@ -555,13 +577,13 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, rep
         return;
     }
     // TS references.
-    if (group_replacements.isTsReference(ref)) {
+    if (index.isTsReference(ref)) {
         const toArrayCallExpr = checkTsReferenceCallsField(ref, 'toArray');
         if (toArrayCallExpr === null) {
             return;
         }
         const toArrayExpr = toArrayCallExpr.expression;
-        replacements.push(new group_replacements.Replacement(group_replacements.projectFile(toArrayExpr.getSourceFile(), info), new group_replacements.TextUpdate({
+        replacements.push(new index.Replacement(index.projectFile(toArrayExpr.getSourceFile(), info), new index.TextUpdate({
             // Delete from expression end to call end. E.g. `.toArray(<..>)`.
             position: toArrayExpr.expression.getEnd(),
             end: toArrayCallExpr.getEnd(),
@@ -574,9 +596,9 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, rep
     if (callExpr === null) {
         return;
     }
-    const file = group_replacements.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
-    const offset = group_replacements.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new group_replacements.Replacement(file, new group_replacements.TextUpdate({
+    const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new index.Replacement(file, new index.TextUpdate({
         // Delete from expression end to call end. E.g. `.toArray(<..>)`.
         position: offset + callExpr.receiver.receiver.sourceSpan.end,
         end: offset + callExpr.sourceSpan.end,
@@ -585,7 +607,7 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, rep
 }
 
 function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+    if (!index.isHostBindingReference(ref) && !index.isTemplateReference(ref) && !index.isTsReference(ref)) {
         return;
     }
     if (knownQueries.isFieldIncompatible(ref.target)) {
@@ -594,13 +616,13 @@ function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replac
     if (!globalMetadata.knownQueryFields[ref.target.key]?.isMulti) {
         return;
     }
-    if (group_replacements.isTsReference(ref)) {
+    if (index.isTsReference(ref)) {
         const getCallExpr = checkTsReferenceCallsField(ref, 'get');
         if (getCallExpr === null) {
             return;
         }
         const getExpr = getCallExpr.expression;
-        replacements.push(new group_replacements.Replacement(group_replacements.projectFile(getExpr.getSourceFile(), info), new group_replacements.TextUpdate({
+        replacements.push(new index.Replacement(index.projectFile(getExpr.getSourceFile(), info), new index.TextUpdate({
             position: getExpr.name.getStart(),
             end: getExpr.name.getEnd(),
             toInsert: 'at',
@@ -612,9 +634,9 @@ function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replac
     if (callExpr === null) {
         return;
     }
-    const file = group_replacements.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
-    const offset = group_replacements.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new group_replacements.Replacement(file, new group_replacements.TextUpdate({
+    const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new index.Replacement(file, new index.TextUpdate({
         position: offset + callExpr.receiver.nameSpan.start,
         end: offset + callExpr.receiver.nameSpan.end,
         toInsert: 'at',
@@ -630,7 +652,7 @@ const problematicQueryListMethods = [
     'destroy',
 ];
 function checkForIncompatibleQueryListAccesses(ref, result) {
-    if (group_replacements.isTsReference(ref)) {
+    if (index.isTsReference(ref)) {
         for (const problematicFn of problematicQueryListMethods) {
             const access = checkTsReferenceAccessesField(ref, problematicFn);
             if (access !== null) {
@@ -639,7 +661,7 @@ function checkForIncompatibleQueryListAccesses(ref, result) {
             }
         }
     }
-    if (group_replacements.isHostBindingReference(ref) || group_replacements.isTemplateReference(ref)) {
+    if (index.isHostBindingReference(ref) || index.isTemplateReference(ref)) {
         for (const problematicFn of problematicQueryListMethods) {
             const access = checkNonTsReferenceAccessesField(ref, problematicFn);
             if (access !== null) {
@@ -655,7 +677,7 @@ const mapping = new Map([
     ['last', 'at(-1)!'],
 ]);
 function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, knownQueries, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+    if (!index.isHostBindingReference(ref) && !index.isTemplateReference(ref) && !index.isTsReference(ref)) {
         return;
     }
     if (knownQueries.isFieldIncompatible(ref.target)) {
@@ -664,12 +686,12 @@ function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, known
     if (!globalMetadata.knownQueryFields[ref.target.key]?.isMulti) {
         return;
     }
-    if (group_replacements.isTsReference(ref)) {
+    if (index.isTsReference(ref)) {
         const expr = checkTsReferenceAccessesField(ref, 'first') ?? checkTsReferenceAccessesField(ref, 'last');
         if (expr === null) {
             return;
         }
-        replacements.push(new group_replacements.Replacement(group_replacements.projectFile(expr.getSourceFile(), info), new group_replacements.TextUpdate({
+        replacements.push(new index.Replacement(index.projectFile(expr.getSourceFile(), info), new index.TextUpdate({
             position: expr.name.getStart(),
             end: expr.name.getEnd(),
             toInsert: mapping.get(expr.name.text),
@@ -681,16 +703,16 @@ function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, known
     if (expr === null) {
         return;
     }
-    const file = group_replacements.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
-    const offset = group_replacements.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
-    replacements.push(new group_replacements.Replacement(file, new group_replacements.TextUpdate({
+    const file = index.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = index.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new index.Replacement(file, new index.TextUpdate({
         position: offset + expr.nameSpan.start,
         end: offset + expr.nameSpan.end,
         toInsert: mapping.get(expr.name),
     })));
 }
 
-class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
+class SignalQueriesMigration extends index.TsurgeComplexMigration {
     constructor(config = {}) {
         super();
         this.config = config;
@@ -709,7 +731,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
             potentialProblematicReferenceForMultiQueries: {},
             reusableAnalysisReferences: null,
         };
-        const groupedAstVisitor = new group_replacements.GroupedTsAstVisitor(sourceFiles);
+        const groupedAstVisitor = new migrate_ts_type_references.GroupedTsAstVisitor(sourceFiles);
         const referenceResult = { references: [] };
         const classesWithFilteredQueries = new Set();
         const filteredQueriesForCompilationUnit = new Map();
@@ -721,7 +743,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                     key: extractedQuery.id,
                     node: queryNode,
                 };
-                const containingFile = group_replacements.projectFile(queryNode.getSourceFile(), info);
+                const containingFile = index.projectFile(queryNode.getSourceFile(), info);
                 // If we have a config filter function, use it here for later
                 // perf-boosted reference lookups. Useful in non-batch mode.
                 if (this.config.shouldMigrateQuery === undefined ||
@@ -736,7 +758,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                     isMulti: extractedQuery.queryInfo.first === false,
                 };
                 if (ts__default["default"].isAccessor(queryNode)) {
-                    markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, group_replacements.FieldIncompatibilityReason.Accessor);
+                    markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.Accessor);
                 }
                 // Detect queries with union types that are uncommon to be
                 // automatically migrate-able. E.g. `refs: ElementRef|null`,
@@ -746,7 +768,14 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                     // Either too large union, or doesn't match `T|undefined`.
                     (queryNode.type.types.length > 2 ||
                         !queryNode.type.types.some((t) => t.kind === ts__default["default"].SyntaxKind.UndefinedKeyword))) {
-                    markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, group_replacements.FieldIncompatibilityReason.SignalQueries__IncompatibleMultiUnionType);
+                    markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__IncompatibleMultiUnionType);
+                }
+                // Migrating fields with `@HostBinding` is incompatible as
+                // the host binding decorator does not invoke the signal.
+                const hostBindingDecorators = checker.getAngularDecorators(extractedQuery.fieldDecorators, ['HostBinding'], 
+                /* isCore */ false);
+                if (hostBindingDecorators.length > 0) {
+                    markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.SignalIncompatibleWithHostBinding);
                 }
             }
         };
@@ -774,15 +803,15 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 return descriptor;
             },
         };
-        groupedAstVisitor.register(group_replacements.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, allFieldsOrKnownQueries, 
+        groupedAstVisitor.register(index.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, allFieldsOrKnownQueries, 
         // In non-batch mode, we know what inputs exist and can optimize the reference
         // resolution significantly (for e.g. VSCode integration)— as we know what
         // field names may be used to reference potential queries.
         this.config.assumeNonBatch
             ? new Set(Array.from(filteredQueriesForCompilationUnit.values()).map((f) => f.fieldName))
             : null, referenceResult).visitor);
-        const inheritanceGraph = new group_replacements.InheritanceGraph(checker$1).expensivePopulate(info.sourceFiles);
-        group_replacements.checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedAstVisitor, {
+        const inheritanceGraph = new migrate_ts_type_references.InheritanceGraph(checker$1).expensivePopulate(info.sourceFiles);
+        migrate_ts_type_references.checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedAstVisitor, {
             ...allFieldsOrKnownQueries,
             isFieldIncompatible: (f) => res.potentialProblematicQueries[f.key]?.fieldReason !== null ||
                 res.potentialProblematicQueries[f.key]?.classReason !== null,
@@ -802,16 +831,16 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         // Determine incompatible queries based on problematic references
         // we saw in TS code, templates or host bindings.
         for (const ref of referenceResult.references) {
-            if (group_replacements.isTsReference(ref) && ref.from.isWrite) {
-                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, group_replacements.FieldIncompatibilityReason.WriteAssignment);
+            if (index.isTsReference(ref) && ref.from.isWrite) {
+                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, migrate_ts_type_references.FieldIncompatibilityReason.WriteAssignment);
             }
-            if ((group_replacements.isTemplateReference(ref) || group_replacements.isHostBindingReference(ref)) && ref.from.isWrite) {
-                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, group_replacements.FieldIncompatibilityReason.WriteAssignment);
+            if ((index.isTemplateReference(ref) || index.isHostBindingReference(ref)) && ref.from.isWrite) {
+                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, migrate_ts_type_references.FieldIncompatibilityReason.WriteAssignment);
             }
             // TODO: Remove this when we support signal narrowing in templates.
             // https://github.com/angular/angular/pull/55456.
-            if (group_replacements.isTemplateReference(ref) && ref.from.isLikelyPartOfNarrowing) {
-                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, group_replacements.FieldIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet);
+            if (index.isTemplateReference(ref) && ref.from.isLikelyPartOfNarrowing) {
+                markFieldIncompatibleInMetadata(res.potentialProblematicQueries, ref.target.key, migrate_ts_type_references.FieldIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet);
             }
             // Check for other incompatible query list accesses.
             checkForIncompatibleQueryListAccesses(ref, res);
@@ -819,7 +848,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         if (this.config.assumeNonBatch) {
             res.reusableAnalysisReferences = referenceResult.references;
         }
-        return group_replacements.confirmAsSerializable(res);
+        return index.confirmAsSerializable(res);
     }
     async merge(units) {
         const merged = {
@@ -851,11 +880,11 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         for (const unit of units) {
             for (const id of Object.keys(unit.potentialProblematicReferenceForMultiQueries)) {
                 if (merged.knownQueryFields[id]?.isMulti) {
-                    markFieldIncompatibleInMetadata(merged.problematicQueries, id, group_replacements.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed);
+                    markFieldIncompatibleInMetadata(merged.problematicQueries, id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed);
                 }
             }
         }
-        return group_replacements.confirmAsSerializable(merged);
+        return index.confirmAsSerializable(merged);
     }
     async migrate(globalMetadata, info) {
         assert__default["default"](info.ngCompiler !== null, 'Expected queries migration to have an Angular program.');
@@ -909,21 +938,21 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         // lookups below.
         const fieldNamesToConsiderForReferenceLookup = new Set(Object.values(globalMetadata.knownQueryFields).map((f) => f.fieldName));
         // Find all references.
-        const groupedAstVisitor = new group_replacements.GroupedTsAstVisitor(sourceFiles);
+        const groupedAstVisitor = new migrate_ts_type_references.GroupedTsAstVisitor(sourceFiles);
         // Re-use previous reference result if available, instead of
         // looking for references which is quite expensive.
         if (globalMetadata.reusableAnalysisReferences !== null) {
             referenceResult.references = globalMetadata.reusableAnalysisReferences;
         }
         else {
-            groupedAstVisitor.register(group_replacements.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, knownQueries, fieldNamesToConsiderForReferenceLookup, referenceResult).visitor);
+            groupedAstVisitor.register(index.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, knownQueries, fieldNamesToConsiderForReferenceLookup, referenceResult).visitor);
         }
         // Check inheritance.
         // NOTE: Inheritance is only checked in the migrate stage as we cannot reliably
         // check during analyze— where we don't know what fields from foreign `.d.ts`
         // files refer to queries or not.
-        const inheritanceGraph = new group_replacements.InheritanceGraph(checker$1).expensivePopulate(info.sourceFiles);
-        group_replacements.checkInheritanceOfKnownFields(inheritanceGraph, metaReader, knownQueries, {
+        const inheritanceGraph = new migrate_ts_type_references.InheritanceGraph(checker$1).expensivePopulate(info.sourceFiles);
+        migrate_ts_type_references.checkInheritanceOfKnownFields(inheritanceGraph, metaReader, knownQueries, {
             getFieldsForClass: (n) => knownQueries.getQueryFieldsOfClass(n) ?? [],
             isClassWithKnownFields: (clazz) => knownQueries.getQueryFieldsOfClass(clazz) !== undefined,
         });
@@ -943,7 +972,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
             if (incompatibility !== null) {
                 // Add a TODO for the incompatible query, if desired.
                 if (this.config.insertTodosForSkippedFields) {
-                    replacements.push(...group_replacements.insertTodoForIncompatibility(node, info, incompatibility, {
+                    replacements.push(...migrate_ts_type_references.insertTodoForIncompatibility(node, info, incompatibility, {
                         single: 'query',
                         plural: 'queries',
                     }));
@@ -951,7 +980,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 updateFileState(filesWithIncompleteMigration, sf, extractedQuery.kind);
                 continue;
             }
-            replacements.push(...computeReplacementsToMigrateQuery(node, extractedQuery, importManager, info, printer));
+            replacements.push(...computeReplacementsToMigrateQuery(node, extractedQuery, importManager, info, printer, info.userOptions, checker$1));
         }
         // Migrate references.
         const referenceMigrationHost = {
@@ -962,10 +991,10 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 .getQueryFieldsOfClass(clazz)
                 ?.some((q) => !knownQueries.isFieldIncompatible(q)),
         };
-        group_replacements.migrateTypeScriptReferences(referenceMigrationHost, referenceResult.references, checker$1, info);
+        migrate_ts_type_references.migrateTypeScriptReferences(referenceMigrationHost, referenceResult.references, checker$1, info);
         migrateTemplateReferences(referenceMigrationHost, referenceResult.references);
         migrateHostBindings(referenceMigrationHost, referenceResult.references, info);
-        group_replacements.migrateTypeScriptTypeReferences(referenceMigrationHost, referenceResult.references, importManager, info);
+        migrate_ts_type_references.migrateTypeScriptTypeReferences(referenceMigrationHost, referenceResult.references, importManager, info);
         // Fix problematic calls, like `QueryList#toArray`, or `QueryList#get`.
         for (const ref of referenceResult.references) {
             removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, replacements);
@@ -989,7 +1018,7 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 importManager.removeImport(file, 'QueryList', '@angular/core');
             }
         }
-        group_replacements.applyImportManagerChanges(importManager, replacements, sourceFiles, info);
+        index.applyImportManagerChanges(importManager, replacements, sourceFiles, info);
         return { replacements, knownQueries };
     }
     async stats(globalMetadata) {
@@ -1010,13 +1039,13 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
             }
             incompatibleQueries++;
             if (info.classReason !== null) {
-                const reasonName = group_replacements.ClassIncompatibilityReason[info.classReason];
+                const reasonName = migrate_ts_type_references.ClassIncompatibilityReason[info.classReason];
                 const key = `incompat-class-${reasonName}`;
                 classIncompatibleCounts[key] ??= 0;
                 classIncompatibleCounts[key]++;
             }
             if (info.fieldReason !== null) {
-                const reasonName = group_replacements.FieldIncompatibilityReason[info.fieldReason];
+                const reasonName = migrate_ts_type_references.FieldIncompatibilityReason[info.fieldReason];
                 const key = `incompat-field-${reasonName}`;
                 fieldIncompatibleCounts[key] ??= 0;
                 fieldIncompatibleCounts[key]++;
@@ -1052,7 +1081,7 @@ function migrate(options) {
         if (!buildPaths.length && !testPaths.length) {
             throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run signal queries migration.');
         }
-        const fs = new group_replacements.DevkitMigrationFilesystem(tree);
+        const fs = new index.DevkitMigrationFilesystem(tree);
         checker.setFileSystem(fs);
         const migration = new SignalQueriesMigration({
             bestEffortMode: options.bestEffortMode,
@@ -1089,7 +1118,7 @@ function migrate(options) {
         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 changesPerFile = index.groupReplacementsByFile(replacements);
             for (const [file, changes] of changesPerFile) {
                 if (!replacementsPerFile.has(file)) {
                     replacementsPerFile.set(file, changes);