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

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -9,19 +9,21 @@
 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-e1b5cbf8.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
+var combine_units = require('./combine_units-c52492ab.js');
 require('os');
 var ts = require('typescript');
-var checker = require('./checker-3b2ea20f.js');
-var program = require('./program-6534a30a.js');
-require('path');
+var checker = require('./checker-2451e7c5.js');
+var program = require('./program-58424797.js');
 var assert = require('assert');
+require('path');
+var migrate_ts_type_references = require('./migrate_ts_type_references-ab18a7c3.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
+require('./leading_space-6e7a8ec6.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -36,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 (!combine_units.isHostBindingReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -60,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 combine_units.Replacement(combine_units.projectFile(bindingField.getSourceFile(), info), new combine_units.TextUpdate({ position: readEndPos, end: readEndPos, toInsert: appendText })));
     }
 }
 
@@ -72,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 (!combine_units.isTemplateReference(reference)) {
             continue;
         }
         // Skip references to incompatible inputs.
@@ -89,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 combine_units.Replacement(reference.from.templateFile, new combine_units.TextUpdate({
             position: reference.from.read.sourceSpan.end,
             end: reference.from.read.sourceSpan.end,
             toInsert: appendText,
@@ -137,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,
@@ -171,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 combine_units.Replacement(combine_units.projectFile(node.getSourceFile(), info), new combine_units.TextUpdate({
             position: node.getStart(),
             end: node.getEnd(),
             toInsert: printer.printNode(ts__default["default"].EmitHint.Unspecified, updated, sf),
@@ -238,7 +260,10 @@ function getUniqueIDForClassProperty(property, info) {
     if (!ts__default["default"].isClassDeclaration(property.parent) || property.parent.name === undefined) {
         return null;
     }
-    const id = group_replacements.projectFile(property.getSourceFile(), info).id.replace(/\.d\.ts$/, '.ts');
+    if (property.name === undefined) {
+        return null;
+    }
+    const id = combine_units.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
@@ -252,7 +277,7 @@ function getUniqueIDForClassProperty(property, info) {
  * returns its resolved metadata if possible.
  */
 function extractSourceQueryDefinition(node, reflector, evaluator, info) {
-    if (!ts__default["default"].isPropertyDeclaration(node) ||
+    if ((!ts__default["default"].isPropertyDeclaration(node) && !ts__default["default"].isAccessor(node)) ||
         !ts__default["default"].isClassDeclaration(node.parent) ||
         node.parent.name === undefined ||
         !ts__default["default"].isIdentifier(node.name)) {
@@ -284,32 +309,72 @@ function extractSourceQueryDefinition(node, reflector, evaluator, info) {
     else {
         throw new Error('Unexpected query decorator detected.');
     }
-    const queryInfo = program.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
+    let queryInfo = null;
+    try {
+        queryInfo = program.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
+    }
+    catch (e) {
+        if (!(e instanceof checker.FatalDiagnosticError)) {
+            throw e;
+        }
+        console.error(`Skipping query: ${e.node.getSourceFile().fileName}: ${e.toString()}`);
+        return null;
+    }
     return {
         id,
         kind,
         args: decorator.args ?? [],
         queryInfo,
-        node,
+        node: node,
+        fieldDecorators: decorators,
     };
 }
 
+function markFieldIncompatibleInMetadata(data, id, reason) {
+    const existing = data[id];
+    if (existing === undefined) {
+        data[id] = {
+            fieldReason: reason,
+            classReason: null,
+        };
+    }
+    else if (existing.fieldReason === null) {
+        existing.fieldReason = reason;
+    }
+    else {
+        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 &&
+            !migrate_ts_type_references.nonIgnorableFieldIncompatibilities.includes(query.fieldReason)) {
+            query.fieldReason = null;
+        }
+    }
+}
+
 class KnownQueries {
-    constructor(info, globalMetadata) {
+    info;
+    config;
+    globalMetadata;
+    classToQueryFields = new Map();
+    knownQueryIDs = new Map();
+    constructor(info, config, globalMetadata) {
         this.info = info;
+        this.config = config;
         this.globalMetadata = globalMetadata;
-        this.classToQueryFields = new Map();
-        this.knownQueryIDs = new Map();
     }
     isFieldIncompatible(descriptor) {
-        return this.globalMetadata.problematicQueries[descriptor.key] !== undefined;
+        return this.getIncompatibilityForField(descriptor) !== null;
     }
-    markFieldIncompatible(field) {
-        this.globalMetadata.problematicQueries[field.key] = true;
+    markFieldIncompatible(field, incompatibility) {
+        markFieldIncompatibleInMetadata(this.globalMetadata.problematicQueries, field.key, incompatibility.reason);
     }
-    markClassIncompatible(node) {
+    markClassIncompatible(node, reason) {
         this.classToQueryFields.get(node)?.forEach((f) => {
-            this.globalMetadata.problematicQueries[f.key] = true;
+            this.globalMetadata.problematicQueries[f.key] ??= { classReason: null, fieldReason: null };
+            this.globalMetadata.problematicQueries[f.key].classReason = reason;
         });
     }
     registerQueryField(queryField, id) {
@@ -321,6 +386,15 @@ class KnownQueries {
             node: queryField,
         });
         this.knownQueryIDs.set(id, { key: id, node: queryField });
+        const descriptor = { key: id, node: queryField };
+        const file = combine_units.projectFile(queryField.getSourceFile(), this.info);
+        if (this.config.shouldMigrateQuery !== undefined &&
+            !this.config.shouldMigrateQuery(descriptor, file)) {
+            this.markFieldIncompatible(descriptor, {
+                context: null,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.SkippedViaConfigFilter,
+            });
+        }
     }
     attemptRetrieveDescriptorFromSymbol(symbol) {
         const descriptor = getClassFieldDescriptorForSymbol(symbol, this.info);
@@ -339,16 +413,67 @@ class KnownQueries {
         return Array.from(this.classToQueryFields.keys()).filter((c) => ts__default["default"].isClassDeclaration(c));
     }
     captureKnownFieldInheritanceRelationship(derived, parent) {
-        if (this.isFieldIncompatible(parent) || this.isFieldIncompatible(derived)) {
-            this.markFieldIncompatible(parent);
-            this.markFieldIncompatible(derived);
+        // Note: The edge problematic pattern recognition is not as good as the one
+        // we have in the signal input migration. That is because we couldn't trivially
+        // build up an inheritance graph during analyze phase where we DON'T know what
+        // fields refer to queries. Usually we'd use the graph to smartly propagate
+        // incompatibilities using topological sort. This doesn't work here and is
+        // unnecessarily complex, so we try our best at detecting direct edge
+        // incompatibilities (which are quite order dependent).
+        if (this.isFieldIncompatible(parent) && !this.isFieldIncompatible(derived)) {
+            this.markFieldIncompatible(derived, {
+                context: null,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.ParentIsIncompatible,
+            });
+            return;
+        }
+        if (this.isFieldIncompatible(derived) && !this.isFieldIncompatible(parent)) {
+            this.markFieldIncompatible(parent, {
+                context: null,
+                reason: migrate_ts_type_references.FieldIncompatibilityReason.DerivedIsIncompatible,
+            });
         }
     }
     captureUnknownDerivedField(field) {
-        this.markFieldIncompatible(field);
+        this.markFieldIncompatible(field, {
+            context: null,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.OverriddenByDerivedClass,
+        });
     }
     captureUnknownParentField(field) {
-        this.markFieldIncompatible(field);
+        this.markFieldIncompatible(field, {
+            context: null,
+            reason: migrate_ts_type_references.FieldIncompatibilityReason.TypeConflictWithBaseClass,
+        });
+    }
+    getIncompatibilityForField(descriptor) {
+        const problematicInfo = this.globalMetadata.problematicQueries[descriptor.key];
+        if (problematicInfo === undefined) {
+            return null;
+        }
+        if (problematicInfo.fieldReason !== null) {
+            return { context: null, reason: problematicInfo.fieldReason };
+        }
+        if (problematicInfo.classReason !== null) {
+            return problematicInfo.classReason;
+        }
+        return null;
+    }
+    getIncompatibilityTextForField(field) {
+        const incompatibilityInfo = this.globalMetadata.problematicQueries[field.key];
+        if (incompatibilityInfo.fieldReason !== null) {
+            return migrate_ts_type_references.getMessageForFieldIncompatibility(incompatibilityInfo.fieldReason, {
+                single: 'query',
+                plural: 'queries',
+            });
+        }
+        if (incompatibilityInfo.classReason !== null) {
+            return migrate_ts_type_references.getMessageForClassIncompatibility(incompatibilityInfo.classReason, {
+                single: 'query',
+                plural: 'queries',
+            });
+        }
+        return null;
     }
 }
 
@@ -376,7 +501,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 = combine_units.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)) {
@@ -444,21 +569,24 @@ function checkNonTsReferenceCallsField(ref, fieldName) {
     return potentialCall;
 }
 
-function removeQueryListToArrayCall(ref, info, globalMetadata, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+function removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, replacements) {
+    if (!combine_units.isHostBindingReference(ref) && !combine_units.isTemplateReference(ref) && !combine_units.isTsReference(ref)) {
+        return;
+    }
+    if (knownQueries.isFieldIncompatible(ref.target)) {
         return;
     }
     if (!globalMetadata.knownQueryFields[ref.target.key]?.isMulti) {
         return;
     }
     // TS references.
-    if (group_replacements.isTsReference(ref)) {
+    if (combine_units.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 combine_units.Replacement(combine_units.projectFile(toArrayExpr.getSourceFile(), info), new combine_units.TextUpdate({
             // Delete from expression end to call end. E.g. `.toArray(<..>)`.
             position: toArrayExpr.expression.getEnd(),
             end: toArrayCallExpr.getEnd(),
@@ -471,9 +599,9 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, replacements) {
     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 = combine_units.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = combine_units.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new combine_units.Replacement(file, new combine_units.TextUpdate({
         // Delete from expression end to call end. E.g. `.toArray(<..>)`.
         position: offset + callExpr.receiver.receiver.sourceSpan.end,
         end: offset + callExpr.sourceSpan.end,
@@ -481,20 +609,23 @@ function removeQueryListToArrayCall(ref, info, globalMetadata, replacements) {
     })));
 }
 
-function replaceQueryListGetCall(ref, info, globalMetadata, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+function replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replacements) {
+    if (!combine_units.isHostBindingReference(ref) && !combine_units.isTemplateReference(ref) && !combine_units.isTsReference(ref)) {
+        return;
+    }
+    if (knownQueries.isFieldIncompatible(ref.target)) {
         return;
     }
     if (!globalMetadata.knownQueryFields[ref.target.key]?.isMulti) {
         return;
     }
-    if (group_replacements.isTsReference(ref)) {
+    if (combine_units.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 combine_units.Replacement(combine_units.projectFile(getExpr.getSourceFile(), info), new combine_units.TextUpdate({
             position: getExpr.name.getStart(),
             end: getExpr.name.getEnd(),
             toInsert: 'at',
@@ -506,9 +637,9 @@ function replaceQueryListGetCall(ref, info, globalMetadata, replacements) {
     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 = combine_units.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = combine_units.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new combine_units.Replacement(file, new combine_units.TextUpdate({
         position: offset + callExpr.receiver.nameSpan.start,
         end: offset + callExpr.receiver.nameSpan.end,
         toInsert: 'at',
@@ -524,7 +655,7 @@ const problematicQueryListMethods = [
     'destroy',
 ];
 function checkForIncompatibleQueryListAccesses(ref, result) {
-    if (group_replacements.isTsReference(ref)) {
+    if (combine_units.isTsReference(ref)) {
         for (const problematicFn of problematicQueryListMethods) {
             const access = checkTsReferenceAccessesField(ref, problematicFn);
             if (access !== null) {
@@ -533,7 +664,7 @@ function checkForIncompatibleQueryListAccesses(ref, result) {
             }
         }
     }
-    if (group_replacements.isHostBindingReference(ref) || group_replacements.isTemplateReference(ref)) {
+    if (combine_units.isHostBindingReference(ref) || combine_units.isTemplateReference(ref)) {
         for (const problematicFn of problematicQueryListMethods) {
             const access = checkNonTsReferenceAccessesField(ref, problematicFn);
             if (access !== null) {
@@ -548,19 +679,22 @@ const mapping = new Map([
     ['first', 'at(0)!'],
     ['last', 'at(-1)!'],
 ]);
-function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, replacements) {
-    if (!group_replacements.isHostBindingReference(ref) && !group_replacements.isTemplateReference(ref) && !group_replacements.isTsReference(ref)) {
+function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, knownQueries, replacements) {
+    if (!combine_units.isHostBindingReference(ref) && !combine_units.isTemplateReference(ref) && !combine_units.isTsReference(ref)) {
+        return;
+    }
+    if (knownQueries.isFieldIncompatible(ref.target)) {
         return;
     }
     if (!globalMetadata.knownQueryFields[ref.target.key]?.isMulti) {
         return;
     }
-    if (group_replacements.isTsReference(ref)) {
+    if (combine_units.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 combine_units.Replacement(combine_units.projectFile(expr.getSourceFile(), info), new combine_units.TextUpdate({
             position: expr.name.getStart(),
             end: expr.name.getEnd(),
             toInsert: mapping.get(expr.name.text),
@@ -572,16 +706,17 @@ function replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, repla
     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 = combine_units.isHostBindingReference(ref) ? ref.from.file : ref.from.templateFile;
+    const offset = combine_units.isHostBindingReference(ref) ? ref.from.hostPropertyNode.getStart() + 1 : 0;
+    replacements.push(new combine_units.Replacement(file, new combine_units.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 combine_units.TsurgeComplexMigration {
+    config;
     constructor(config = {}) {
         super();
         this.config = config;
@@ -600,21 +735,24 @@ 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 WeakSet();
+        const classesWithFilteredQueries = new Set();
         const filteredQueriesForCompilationUnit = new Map();
         const findQueryDefinitionsVisitor = (node) => {
             const extractedQuery = extractSourceQueryDefinition(node, reflector, evaluator, info);
             if (extractedQuery !== null) {
+                const queryNode = extractedQuery.node;
                 const descriptor = {
                     key: extractedQuery.id,
-                    node: extractedQuery.node,
+                    node: queryNode,
                 };
-                const containingFile = group_replacements.projectFile(descriptor.node.getSourceFile(), info);
+                const containingFile = combine_units.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 ||
                     this.config.shouldMigrateQuery(descriptor, containingFile)) {
-                    classesWithFilteredQueries.add(extractedQuery.node.parent);
+                    classesWithFilteredQueries.add(queryNode.parent);
                     filteredQueriesForCompilationUnit.set(extractedQuery.id, {
                         fieldName: extractedQuery.queryInfo.propertyName,
                     });
@@ -623,20 +761,32 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                     fieldName: extractedQuery.queryInfo.propertyName,
                     isMulti: extractedQuery.queryInfo.first === false,
                 };
+                if (ts__default["default"].isAccessor(queryNode)) {
+                    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`,
+                // or `ElementRef|SomeOtherType`.
+                if (queryNode.type !== undefined &&
+                    ts__default["default"].isUnionTypeNode(queryNode.type) &&
+                    // 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, 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);
+                }
             }
         };
+        this.config.reportProgressFn?.(20, 'Scanning for queries..');
         groupedAstVisitor.register(findQueryDefinitionsVisitor);
-        if (this.config.assumeNonBatch) {
-            // In non-batch, we need to find queries before, so we can perform
-            // improved reference resolution.
-            this.config.reportProgressFn?.(20, 'Scanning for queries..');
-            groupedAstVisitor.execute();
-            this.config.reportProgressFn?.(30, 'Scanning for references..');
-        }
-        else {
-            this.config.reportProgressFn?.(20, 'Scanning for queries and references..');
-        }
-        groupedAstVisitor.register(group_replacements.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, {
+        groupedAstVisitor.execute();
+        const allFieldsOrKnownQueries = {
             // Note: We don't support cross-target migration of `Partial<T>` usages.
             // This is an acceptable limitation for performance reasons.
             shouldTrackClassReference: (node) => classesWithFilteredQueries.has(node),
@@ -650,35 +800,51 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                     !filteredQueriesForCompilationUnit.has(descriptor.key)) {
                     return null;
                 }
-                // TODO: Also consider skipping if we know this cannot be a query.
-                // e.g. missing class decorators or some other checks.
                 // In batch mode, we eagerly, rather expensively, track all references.
                 // We don't know yet if something refers to a different query or not, so we
                 // eagerly detect such and later filter those problematic references that
                 // turned out to refer to queries (once we have the global metadata).
                 return descriptor;
             },
-        }, 
+        };
+        groupedAstVisitor.register(combine_units.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 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,
+            markClassIncompatible: (clazz, reason) => {
+                for (const field of clazz.members) {
+                    const key = getUniqueIDForClassProperty(field, info);
+                    if (key !== null) {
+                        res.potentialProblematicQueries[key] ??= { classReason: null, fieldReason: null };
+                        res.potentialProblematicQueries[key].classReason = reason;
+                    }
+                }
+            },
+            markFieldIncompatible: (f, incompatibility) => markFieldIncompatibleInMetadata(res.potentialProblematicQueries, f.key, incompatibility.reason),
+        }, () => Array.from(classesWithFilteredQueries));
+        this.config.reportProgressFn?.(60, 'Scanning for references and problematic patterns..');
         groupedAstVisitor.execute();
         // 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) {
-                res.potentialProblematicQueries[ref.target.key] = true;
+            if (combine_units.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) {
-                res.potentialProblematicQueries[ref.target.key] = true;
+            if ((combine_units.isTemplateReference(ref) || combine_units.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) {
-                res.potentialProblematicQueries[ref.target.key] = true;
+            if (combine_units.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);
@@ -686,34 +852,60 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         if (this.config.assumeNonBatch) {
             res.reusableAnalysisReferences = referenceResult.references;
         }
-        return group_replacements.confirmAsSerializable(res);
+        return combine_units.confirmAsSerializable(res);
     }
-    async merge(units) {
-        const merged = {
+    async combine(unitA, unitB) {
+        const combined = {
             knownQueryFields: {},
-            problematicQueries: {},
+            potentialProblematicQueries: {},
+            potentialProblematicReferenceForMultiQueries: {},
             reusableAnalysisReferences: null,
         };
-        for (const unit of units) {
+        for (const unit of [unitA, unitB]) {
             for (const [id, value] of Object.entries(unit.knownQueryFields)) {
-                merged.knownQueryFields[id] = value;
+                combined.knownQueryFields[id] = value;
             }
-            for (const id of Object.keys(unit.potentialProblematicQueries)) {
-                merged.problematicQueries[id] = true;
+            for (const [id, info] of Object.entries(unit.potentialProblematicQueries)) {
+                if (info.fieldReason !== null) {
+                    markFieldIncompatibleInMetadata(combined.potentialProblematicQueries, id, info.fieldReason);
+                }
+                if (info.classReason !== null) {
+                    combined.potentialProblematicQueries[id] ??= {
+                        classReason: null,
+                        fieldReason: null,
+                    };
+                    combined.potentialProblematicQueries[id].classReason =
+                        info.classReason;
+                }
+            }
+            for (const id of Object.keys(unit.potentialProblematicReferenceForMultiQueries)) {
+                combined.potentialProblematicReferenceForMultiQueries[id] = true;
             }
             if (unit.reusableAnalysisReferences !== null) {
-                assert__default["default"](units.length === 1, 'Expected migration to not run in batch mode');
-                merged.reusableAnalysisReferences = unit.reusableAnalysisReferences;
+                combined.reusableAnalysisReferences = unit.reusableAnalysisReferences;
             }
         }
-        for (const unit of units) {
+        for (const unit of [unitA, unitB]) {
             for (const id of Object.keys(unit.potentialProblematicReferenceForMultiQueries)) {
-                if (merged.knownQueryFields[id]?.isMulti) {
-                    merged.problematicQueries[id] = true;
+                if (combined.knownQueryFields[id]?.isMulti) {
+                    markFieldIncompatibleInMetadata(combined.potentialProblematicQueries, id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed);
                 }
             }
         }
-        return group_replacements.confirmAsSerializable(merged);
+        return combine_units.confirmAsSerializable(combined);
+    }
+    async globalMeta(combinedData) {
+        const globalUnitData = {
+            knownQueryFields: combinedData.knownQueryFields,
+            problematicQueries: combinedData.potentialProblematicQueries,
+            reusableAnalysisReferences: combinedData.reusableAnalysisReferences,
+        };
+        for (const id of Object.keys(combinedData.potentialProblematicReferenceForMultiQueries)) {
+            if (combinedData.knownQueryFields[id]?.isMulti) {
+                markFieldIncompatibleInMetadata(globalUnitData.problematicQueries, id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed);
+            }
+        }
+        return combine_units.confirmAsSerializable(globalUnitData);
     }
     async migrate(globalMetadata, info) {
         assert__default["default"](info.ngCompiler !== null, 'Expected queries migration to have an Angular program.');
@@ -729,13 +921,9 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
         const filesWithSourceQueries = new Map();
         const filesWithIncompleteMigration = new Map();
         const filesWithQueryListOutsideOfDeclarations = new WeakSet();
-        const knownQueries = new KnownQueries(info, globalMetadata);
+        const knownQueries = new KnownQueries(info, this.config, globalMetadata);
         const referenceResult = { references: [] };
         const sourceQueries = [];
-        const isMigratedQuery = (descriptor) => globalMetadata.knownQueryFields[descriptor.key] !== undefined &&
-            globalMetadata.problematicQueries[descriptor.key] === undefined &&
-            (this.config.shouldMigrateQuery === undefined ||
-                this.config.shouldMigrateQuery(descriptor, group_replacements.projectFile(descriptor.node.getSourceFile(), info)));
         // Detect all queries in this unit.
         const queryWholeProgramVisitor = (node) => {
             // Detect all SOURCE queries and migrate them, if possible.
@@ -746,7 +934,8 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 return;
             }
             // Detect OTHER queries, inside `.d.ts`. Needed for reference resolution below.
-            if (ts__default["default"].isPropertyDeclaration(node)) {
+            if (ts__default["default"].isPropertyDeclaration(node) ||
+                (ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent))) {
                 const classFieldID = getUniqueIDForClassProperty(node, info);
                 if (classFieldID !== null && globalMetadata.knownQueryFields[classFieldID] !== undefined) {
                     knownQueries.registerQueryField(node, classFieldID);
@@ -770,55 +959,68 @@ 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(combine_units.createFindAllSourceFileReferencesVisitor(info, checker$1, reflector, info.ngCompiler['resourceManager'], evaluator, templateTypeChecker, knownQueries, fieldNamesToConsiderForReferenceLookup, referenceResult).visitor);
         }
-        const inheritanceGraph = new group_replacements.InheritanceGraph(checker$1).expensivePopulate(info.sourceFiles);
-        group_replacements.checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedAstVisitor, knownQueries, () => knownQueries.getAllClassesWithQueries());
-        this.config.reportProgressFn?.(60, 'Checking for problematic patterns..');
-        groupedAstVisitor.execute();
         // Check inheritance.
-        this.config.reportProgressFn?.(70, 'Checking for inheritance patterns..');
-        group_replacements.checkInheritanceOfKnownFields(inheritanceGraph, metaReader, knownQueries, {
+        // 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 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,
         });
+        this.config.reportProgressFn?.(70, 'Checking inheritance..');
+        groupedAstVisitor.execute();
+        if (this.config.bestEffortMode) {
+            filterBestEffortIncompatibilities(knownQueries);
+        }
         this.config.reportProgressFn?.(80, 'Migrating queries..');
         // Migrate declarations.
         for (const extractedQuery of sourceQueries) {
             const node = extractedQuery.node;
             const sf = node.getSourceFile();
             const descriptor = { key: extractedQuery.id, node: extractedQuery.node };
-            if (!isMigratedQuery(descriptor)) {
-                updateFileState(filesWithSourceQueries, sf, extractedQuery.kind);
+            const incompatibility = knownQueries.getIncompatibilityForField(descriptor);
+            updateFileState(filesWithSourceQueries, sf, extractedQuery.kind);
+            if (incompatibility !== null) {
+                // Add a TODO for the incompatible query, if desired.
+                if (this.config.insertTodosForSkippedFields) {
+                    replacements.push(...migrate_ts_type_references.insertTodoForIncompatibility(node, info, incompatibility, {
+                        single: 'query',
+                        plural: 'queries',
+                    }));
+                }
                 updateFileState(filesWithIncompleteMigration, sf, extractedQuery.kind);
                 continue;
             }
-            updateFileState(filesWithSourceQueries, sf, extractedQuery.kind);
-            replacements.push(...computeReplacementsToMigrateQuery(node, extractedQuery, importManager, info, printer));
+            replacements.push(...computeReplacementsToMigrateQuery(node, extractedQuery, importManager, info, printer, info.userOptions, checker$1));
         }
         // Migrate references.
         const referenceMigrationHost = {
             printer,
             replacements,
-            shouldMigrateReferencesToField: (field) => isMigratedQuery(field),
-            shouldMigrateReferencesToClass: (clazz) => !!knownQueries.getQueryFieldsOfClass(clazz)?.some((q) => isMigratedQuery(q)),
+            shouldMigrateReferencesToField: (field) => !knownQueries.isFieldIncompatible(field),
+            shouldMigrateReferencesToClass: (clazz) => !!knownQueries
+                .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, replacements);
-            replaceQueryListGetCall(ref, info, globalMetadata, replacements);
-            replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, replacements);
+            removeQueryListToArrayCall(ref, info, globalMetadata, knownQueries, replacements);
+            replaceQueryListGetCall(ref, info, globalMetadata, knownQueries, replacements);
+            replaceQueryListFirstAndLastReferences(ref, info, globalMetadata, knownQueries, replacements);
         }
         // Remove imports if possible.
         for (const [file, types] of filesWithSourceQueries) {
@@ -837,12 +1039,48 @@ class SignalQueriesMigration extends group_replacements.TsurgeComplexMigration {
                 importManager.removeImport(file, 'QueryList', '@angular/core');
             }
         }
-        group_replacements.applyImportManagerChanges(importManager, replacements, sourceFiles, info);
+        combine_units.applyImportManagerChanges(importManager, replacements, sourceFiles, info);
         return { replacements, knownQueries };
     }
     async stats(globalMetadata) {
-        // TODO: Add statistics.
-        return { counters: {} };
+        let queriesCount = 0;
+        let multiQueries = 0;
+        let incompatibleQueries = 0;
+        const fieldIncompatibleCounts = {};
+        const classIncompatibleCounts = {};
+        for (const query of Object.values(globalMetadata.knownQueryFields)) {
+            queriesCount++;
+            if (query.isMulti) {
+                multiQueries++;
+            }
+        }
+        for (const [id, info] of Object.entries(globalMetadata.problematicQueries)) {
+            if (globalMetadata.knownQueryFields[id] === undefined) {
+                continue;
+            }
+            incompatibleQueries++;
+            if (info.classReason !== null) {
+                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 = migrate_ts_type_references.FieldIncompatibilityReason[info.fieldReason];
+                const key = `incompat-field-${reasonName}`;
+                fieldIncompatibleCounts[key] ??= 0;
+                fieldIncompatibleCounts[key]++;
+            }
+        }
+        return {
+            counters: {
+                queriesCount,
+                multiQueries,
+                incompatibleQueries,
+                ...fieldIncompatibleCounts,
+                ...classIncompatibleCounts,
+            },
+        };
     }
 }
 /**
@@ -862,11 +1100,13 @@ function migrate(options) {
     return async (tree, context) => {
         const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
         if (!buildPaths.length && !testPaths.length) {
-            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run signal input migration.');
+            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 combine_units.DevkitMigrationFilesystem(tree);
         checker.setFileSystem(fs);
         const migration = new SignalQueriesMigration({
+            bestEffortMode: options.bestEffortMode,
+            insertTodosForSkippedFields: options.insertTodos,
             shouldMigrateQuery: (_query, file) => {
                 return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
                     !/(^|\/)node_modules\//.test(file.rootRelativePath));
@@ -894,12 +1134,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);
@@ -918,6 +1163,19 @@ function migrate(options) {
         }
         context.logger.info('');
         context.logger.info(`Successfully migrated to signal queries 🎉`);
+        const { counters: { queriesCount, incompatibleQueries, multiQueries }, } = await migration.stats(globalMeta);
+        const migratedQueries = queriesCount - incompatibleQueries;
+        context.logger.info('');
+        context.logger.info(`Successfully migrated to signal queries 🎉`);
+        context.logger.info(`  -> Migrated ${migratedQueries}/${queriesCount} queries.`);
+        if (incompatibleQueries > 0 && !options.insertTodos) {
+            context.logger.warn(`To see why ${incompatibleQueries} queries couldn't be migrated`);
+            context.logger.warn(`consider re-running with "--insert-todos" or "--best-effort-mode".`);
+        }
+        if (options.bestEffortMode) {
+            context.logger.warn(`You ran with best effort mode. Manually verify all code ` +
+                `works as intended, and fix where necessary.`);
+        }
     };
 }