@angular/core 19.0.0-next.6 → 19.0.0-next.7

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.6
+ * @license Angular v19.0.0-next.7
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -11,10 +11,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var schematics = require('@angular-devkit/schematics');
 var ts = require('typescript');
 var os = require('os');
-var checker = require('./checker-dcf9a14e.js');
-var program = require('./program-4dc8c0fa.js');
+var checker = require('./checker-637eee78.js');
+var program = require('./program-893e3fe7.js');
 require('path');
 var assert = require('assert');
+var leading_space = require('./leading_space-6e7a8ec6.js');
 var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
 var core = require('@angular-devkit/core');
 var path = require('node:path');
@@ -140,10 +141,7 @@ function createFileSystemTsReadDirectoryFn(fs) {
                 }
             }
             return { files, directories };
-        }, (p) => fs.resolve(p), (p) => {
-            const resolvedPath = fs.resolve(p);
-            return fs.exists(resolvedPath) && fs.stat(resolvedPath).isDirectory();
-        });
+        }, (p) => fs.resolve(p), (p) => directoryExists(p));
     };
 }
 
@@ -261,19 +259,25 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
     return null;
 }
 
-/** Reasons why an input cannot be migrated. */
+/**
+ * Reasons why an input cannot be migrated.
+ *
+ * Higher values of incompatibility reasons indicate a more significant
+ * incompatibility reason. Lower ones may be overridden by higher ones.
+ * */
 var InputIncompatibilityReason;
 (function (InputIncompatibilityReason) {
-    InputIncompatibilityReason[InputIncompatibilityReason["SkippedViaConfigFilter"] = 0] = "SkippedViaConfigFilter";
-    InputIncompatibilityReason[InputIncompatibilityReason["Accessor"] = 1] = "Accessor";
-    InputIncompatibilityReason[InputIncompatibilityReason["WriteAssignment"] = 2] = "WriteAssignment";
-    InputIncompatibilityReason[InputIncompatibilityReason["OverriddenByDerivedClass"] = 3] = "OverriddenByDerivedClass";
-    InputIncompatibilityReason[InputIncompatibilityReason["RedeclaredViaDerivedClassInputsArray"] = 4] = "RedeclaredViaDerivedClassInputsArray";
-    InputIncompatibilityReason[InputIncompatibilityReason["TypeConflictWithBaseClass"] = 5] = "TypeConflictWithBaseClass";
-    InputIncompatibilityReason[InputIncompatibilityReason["ParentIsIncompatible"] = 6] = "ParentIsIncompatible";
-    InputIncompatibilityReason[InputIncompatibilityReason["SpyOnThatOverwritesField"] = 7] = "SpyOnThatOverwritesField";
-    InputIncompatibilityReason[InputIncompatibilityReason["PotentiallyNarrowedInTemplateButNoSupportYet"] = 8] = "PotentiallyNarrowedInTemplateButNoSupportYet";
-    InputIncompatibilityReason[InputIncompatibilityReason["RequiredInputButNoGoodExplicitTypeExtractable"] = 9] = "RequiredInputButNoGoodExplicitTypeExtractable";
+    InputIncompatibilityReason[InputIncompatibilityReason["OverriddenByDerivedClass"] = 1] = "OverriddenByDerivedClass";
+    InputIncompatibilityReason[InputIncompatibilityReason["RedeclaredViaDerivedClassInputsArray"] = 2] = "RedeclaredViaDerivedClassInputsArray";
+    InputIncompatibilityReason[InputIncompatibilityReason["TypeConflictWithBaseClass"] = 3] = "TypeConflictWithBaseClass";
+    InputIncompatibilityReason[InputIncompatibilityReason["ParentIsIncompatible"] = 4] = "ParentIsIncompatible";
+    InputIncompatibilityReason[InputIncompatibilityReason["SpyOnThatOverwritesField"] = 5] = "SpyOnThatOverwritesField";
+    InputIncompatibilityReason[InputIncompatibilityReason["PotentiallyNarrowedInTemplateButNoSupportYet"] = 6] = "PotentiallyNarrowedInTemplateButNoSupportYet";
+    InputIncompatibilityReason[InputIncompatibilityReason["RequiredInputButNoGoodExplicitTypeExtractable"] = 7] = "RequiredInputButNoGoodExplicitTypeExtractable";
+    InputIncompatibilityReason[InputIncompatibilityReason["WriteAssignment"] = 8] = "WriteAssignment";
+    InputIncompatibilityReason[InputIncompatibilityReason["Accessor"] = 9] = "Accessor";
+    InputIncompatibilityReason[InputIncompatibilityReason["OutsideOfMigrationScope"] = 10] = "OutsideOfMigrationScope";
+    InputIncompatibilityReason[InputIncompatibilityReason["SkippedViaConfigFilter"] = 11] = "SkippedViaConfigFilter";
 })(InputIncompatibilityReason || (InputIncompatibilityReason = {}));
 /** Reasons why a whole class and its inputs cannot be migrated. */
 var ClassIncompatibilityReason;
@@ -287,6 +291,104 @@ function isInputMemberIncompatibility(value) {
         value.context !== undefined &&
         InputIncompatibilityReason.hasOwnProperty(value.reason));
 }
+/** Picks the more significant input compatibility. */
+function pickInputIncompatibility(a, b) {
+    if (b === null) {
+        return a;
+    }
+    if (a.reason < b.reason) {
+        return b;
+    }
+    return a;
+}
+
+/**
+ * Gets human-readable message information for the given input incompatibility.
+ * This text will be used by the language service, or CLI-based migration.
+ */
+function getMessageForInputIncompatibility(reason) {
+    switch (reason) {
+        case InputIncompatibilityReason.Accessor:
+            return {
+                short: 'Accessor inputs cannot be migrated as they are too complex.',
+                extra: 'The migration potentially requires usage of `effect` or `computed`, but ' +
+                    'the intent is unclear. The migration cannot safely migrate.',
+            };
+        case InputIncompatibilityReason.OverriddenByDerivedClass:
+            return {
+                short: 'The input cannot be migrated because the field is overridden by a subclass.',
+                extra: 'The field in the subclass is not an input, so migrating would break your build.',
+            };
+        case InputIncompatibilityReason.ParentIsIncompatible:
+            return {
+                short: 'This input is inherited from a superclass, but the parent cannot be migrated.',
+                extra: 'Migrating this input would cause your build to fail.',
+            };
+        case InputIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet:
+            return {
+                short: 'This input is used in a control flow expression (e.g. `@if` or `*ngIf`) and ' +
+                    'migrating would break narrowing currently.',
+                extra: `In the future, Angular intends to support narrowing of signals.`,
+            };
+        case InputIncompatibilityReason.RedeclaredViaDerivedClassInputsArray:
+            return {
+                short: 'The input is overridden by a subclass that cannot be migrated.',
+                extra: 'The subclass re-declares this input via the `inputs` array in @Directive/@Component. ' +
+                    'Migrating this input would break your build because the subclass input cannot be migrated.',
+            };
+        case InputIncompatibilityReason.RequiredInputButNoGoodExplicitTypeExtractable:
+            return {
+                short: `Input is required, but the migration cannot determine a good type for the input.`,
+                extra: 'Consider adding an explicit type to make the migration possible.',
+            };
+        case InputIncompatibilityReason.SkippedViaConfigFilter:
+            return {
+                short: `This input is not part of the current migration scope.`,
+                extra: 'Skipped via migration config.',
+            };
+        case InputIncompatibilityReason.SpyOnThatOverwritesField:
+            return {
+                short: 'A jasmine `spyOn` call spies on this input. This breaks with signal inputs.',
+                extra: `Migration cannot safely migrate as "spyOn" writes to the input. Signal inputs are readonly.`,
+            };
+        case InputIncompatibilityReason.TypeConflictWithBaseClass:
+            return {
+                short: 'This input overrides a field from a superclass, while the superclass field is not migrated.',
+                extra: 'Migrating the input would break your build because of a type conflict then.',
+            };
+        case InputIncompatibilityReason.WriteAssignment:
+            return {
+                short: 'Your application code writes to the input. This prevents migration.',
+                extra: 'Signal inputs are readonly, so migrating would break your build.',
+            };
+        case InputIncompatibilityReason.OutsideOfMigrationScope:
+            return {
+                short: 'This input is not part of any source files in your project.',
+                extra: 'The migration excludes inputs if no source file declaring the input was seen.',
+            };
+    }
+}
+/**
+ * Gets human-readable message information for the given input class incompatibility.
+ * This text will be used by the language service, or CLI-based migration.
+ */
+function getMessageForClassIncompatibility(reason) {
+    switch (reason) {
+        case ClassIncompatibilityReason.InputOwningClassReferencedInClassProperty:
+            return {
+                short: 'Class of this input is referenced in the signature of another class.',
+                extra: 'The other class is likely typed to expect a non-migrated field, so ' +
+                    'migration is skipped to not break your build.',
+            };
+        case ClassIncompatibilityReason.ClassManuallyInstantiated:
+            return {
+                short: 'Class of this input is manually instantiated. ' +
+                    'This is discouraged and prevents migration',
+                extra: 'Signal inputs require a DI injection context. Manually instantiating ' +
+                    'breaks this requirement in some cases, so the migration is skipped.',
+            };
+    }
+}
 
 /**
  * Class that holds information about a given directive and its input fields.
@@ -321,7 +423,11 @@ class DirectiveInfo {
      * then the member is as well.
      */
     isInputMemberIncompatible(input) {
-        return this.incompatible !== null || this.memberIncompatibility.has(input.key);
+        return this.getInputMemberIncompatibility(input) !== null;
+    }
+    /** Get incompatibility of the given member, if it's incompatible for migration. */
+    getInputMemberIncompatibility(input) {
+        return this.memberIncompatibility.get(input.key) ?? this.incompatible ?? null;
     }
 }
 
@@ -345,9 +451,11 @@ function isInputContainerNode(node) {
         getMemberName(node) !== null);
 }
 
+/** Code of the error raised by TypeScript when a tsconfig doesn't match any files. */
+const NO_INPUTS_ERROR_CODE = 18003;
 /**
  * Parses the configuration of the given TypeScript project and creates
- * an instance of the Angular compiler for for the project.
+ * an instance of the Angular compiler for the project.
  */
 function createNgtscProgram(absoluteTsconfigPath, fs, optionOverrides = {}) {
     if (fs === undefined) {
@@ -355,9 +463,11 @@ function createNgtscProgram(absoluteTsconfigPath, fs, optionOverrides = {}) {
         checker.setFileSystem(fs);
     }
     const tsconfig = readConfiguration(absoluteTsconfigPath, {}, fs);
-    if (tsconfig.errors.length > 0) {
-        throw new Error(`Tsconfig could not be parsed or is invalid:\n\n` +
-            `${tsconfig.errors.map((e) => e.messageText)}`);
+    // Skip the "No inputs found..." error since we don't want to interrupt the migration if a
+    // tsconfig doesn't match a file. This will result in an empty `Program` which is still valid.
+    const errors = tsconfig.errors.filter((diag) => diag.code !== NO_INPUTS_ERROR_CODE);
+    if (errors.length) {
+        throw new Error(`Tsconfig could not be parsed or is invalid:\n\n` + `${errors.map((e) => e.messageText)}`);
     }
     const tsHost = new NgtscCompilerHost(fs, tsconfig.options);
     const ngtscProgram = new program.NgtscProgram(tsconfig.rootNames, {
@@ -560,8 +670,6 @@ class KnownInputs {
          * Known inputs from the whole program.
          */
         this.knownInputIds = new Map();
-        // TODO: perf comment
-        this.fieldNamesToConsiderForReferenceLookup = new Set();
         /** Known container classes of inputs. */
         this._allClasses = new Set();
         /** Maps classes to their directive info. */
@@ -598,6 +706,7 @@ class KnownInputs {
             metadata: data.metadata,
             descriptor: data.descriptor,
             container: directiveInfo,
+            extendsFrom: null,
             isIncompatible: () => directiveInfo.isInputMemberIncompatible(data.descriptor),
         };
         directiveInfo.inputFields.set(data.descriptor.key, {
@@ -606,9 +715,6 @@ class KnownInputs {
         });
         this.knownInputIds.set(data.descriptor.key, inputInfo);
         this._allClasses.add(data.node.parent);
-        if (this.config.shouldMigrateInput?.(inputInfo) ?? true) {
-            this.fieldNamesToConsiderForReferenceLookup.add(data.descriptor.node.name.text);
-        }
     }
     /** Whether the given input is incompatible for migration. */
     isFieldIncompatible(descriptor) {
@@ -619,6 +725,12 @@ class KnownInputs {
         if (!this.knownInputIds.has(input.key)) {
             throw new Error(`Input cannot be marked as incompatible because it's not registered.`);
         }
+        const inputInfo = this.knownInputIds.get(input.key);
+        const existingIncompatibility = inputInfo.container.getInputMemberIncompatibility(input);
+        // Ensure an existing more significant incompatibility is not overridden.
+        if (existingIncompatibility !== null && isInputMemberIncompatibility(existingIncompatibility)) {
+            incompatibility = pickInputIncompatibility(existingIncompatibility, incompatibility);
+        }
         this.knownInputIds
             .get(input.key)
             .container.memberIncompatibility.set(input.key, incompatibility);
@@ -636,6 +748,24 @@ class KnownInputs {
     shouldTrackClassReference(clazz) {
         return this.isInputContainingClass(clazz);
     }
+    captureKnownFieldInheritanceRelationship(derived, parent) {
+        if (!this.has(derived)) {
+            throw new Error(`Expected input to exist in registry: ${derived.key}`);
+        }
+        this.get(derived).extendsFrom = parent;
+    }
+    captureUnknownDerivedField(field) {
+        this.markFieldIncompatible(field, {
+            context: null,
+            reason: InputIncompatibilityReason.OverriddenByDerivedClass,
+        });
+    }
+    captureUnknownParentField(field) {
+        this.markFieldIncompatible(field, {
+            context: null,
+            reason: InputIncompatibilityReason.TypeConflictWithBaseClass,
+        });
+    }
 }
 
 /**
@@ -860,6 +990,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
             ts__default["default"].factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.UndefinedKeyword),
         ]);
     }
+    let leadingTodoText = null;
     // If the input does not have an initial value, and strict property initialization
     // is disabled, while strict null checks are enabled; then we know that `undefined`
     // cannot be used as initial value, nor do we want to expand the input's type magically.
@@ -872,6 +1003,9 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
         node.exclamationToken === undefined &&
         metadata.required === false &&
         !checker.isTypeAssignableTo(checker.getUndefinedType(), checker.getTypeFromTypeNode(node.type))) {
+        leadingTodoText =
+            'Input is initialized to `undefined` but type does not allow this value. ' +
+                'This worked with `@Input` because your project uses `--strictPropertyInitialization=false`.';
         isUndefinedInitialValue = false;
         initialValue = ts__default["default"].factory.createNonNullExpression(ts__default["default"].factory.createIdentifier('undefined'));
     }
@@ -914,6 +1048,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
         preferShorthandIfPossible,
         originalInputDecorator: metadata.inputDecorator,
         initialValue: isUndefinedInitialValue ? undefined : initialValue,
+        leadingTodoText,
     };
 }
 
@@ -12504,7 +12639,10 @@ function formatValue(value) {
     // Self-closing tags use a special form that concatenates the start and close tag values.
     if (value.flags & I18nParamValueFlags.OpenTag &&
         value.flags & I18nParamValueFlags.CloseTag) {
-        return `${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.CloseTag })}${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.OpenTag })}`;
+        return `${formatValue({
+            ...value,
+            flags: value.flags & ~I18nParamValueFlags.CloseTag,
+        })}${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.OpenTag })}`;
     }
     // If there are no special flags, just return the raw value.
     if (value.flags === I18nParamValueFlags.None) {
@@ -12896,13 +13034,17 @@ class IcuSerializerVisitor {
     visitTagPlaceholder(ph) {
         return ph.isVoid
             ? this.formatPh(ph.startName)
-            : `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+            : `${this.formatPh(ph.startName)}${ph.children
+                .map((child) => child.visit(this))
+                .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitPlaceholder(ph) {
         return this.formatPh(ph.name);
     }
     visitBlockPlaceholder(ph) {
-        return `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+        return `${this.formatPh(ph.startName)}${ph.children
+            .map((child) => child.visit(this))
+            .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitIcuPlaceholder(ph, context) {
         return this.formatPh(ph.name);
@@ -20198,13 +20340,17 @@ class GetMsgSerializerVisitor {
     visitTagPlaceholder(ph) {
         return ph.isVoid
             ? this.formatPh(ph.startName)
-            : `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+            : `${this.formatPh(ph.startName)}${ph.children
+                .map((child) => child.visit(this))
+                .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitPlaceholder(ph) {
         return this.formatPh(ph.name);
     }
     visitBlockPlaceholder(ph) {
-        return `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+        return `${this.formatPh(ph.startName)}${ph.children
+            .map((child) => child.visit(this))
+            .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitIcuPlaceholder(ph, context) {
         return this.formatPh(ph.name);
@@ -24315,7 +24461,7 @@ function wrapI18nIcus(job) {
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Removes any `storeLet` calls that aren't referenced outside of the current view.
@@ -24398,7 +24544,7 @@ function generateLocalLetReferences(job) {
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: removeContentSelectors },
@@ -29874,7 +30020,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.0.0-next.6');
+new Version('19.0.0-next.7');
 
 var _VisitorMode;
 (function (_VisitorMode) {
@@ -30079,9 +30225,12 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
     checkTemplateExpression(activeNode, expressionNode) {
         this.detectedInputReferences = [];
         this.activeTmplAstNode = activeNode;
-        expressionNode.visit(this);
+        expressionNode.visit(this, []);
         return this.detectedInputReferences;
     }
+    visit(ast, context) {
+        super.visit(ast, [...context, ast]);
+    }
     // Keep track when we are inside an object shorthand expression. This is
     // necessary as we need to expand the shorthand to invoke a potential new signal.
     // E.g. `{bla}` may be transformed to `{bla: bla()}`.
@@ -30091,35 +30240,34 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
             ast.values[idx].visit(this, context);
             this.isInsideObjectShorthandExpression = false;
         }
-        super.visitLiteralMap(ast, context);
     }
-    visitPropertyRead(ast) {
-        this._inspectPropertyAccess(ast);
-        super.visitPropertyRead(ast, null);
+    visitPropertyRead(ast, context) {
+        this._inspectPropertyAccess(ast, context);
+        super.visitPropertyRead(ast, context);
     }
-    visitSafePropertyRead(ast) {
-        this._inspectPropertyAccess(ast);
-        super.visitPropertyRead(ast, null);
+    visitSafePropertyRead(ast, context) {
+        this._inspectPropertyAccess(ast, context);
+        super.visitPropertyRead(ast, context);
     }
-    visitPropertyWrite(ast) {
-        this._inspectPropertyAccess(ast);
-        super.visitPropertyWrite(ast, null);
+    visitPropertyWrite(ast, context) {
+        this._inspectPropertyAccess(ast, context);
+        super.visitPropertyWrite(ast, context);
     }
     /**
      * Inspects the property access and attempts to resolve whether they access
      * a known field. If so, the result is captured.
      */
-    _inspectPropertyAccess(ast) {
+    _inspectPropertyAccess(ast, astPath) {
         const isWrite = !!(ast instanceof PropertyWrite ||
             (this.activeTmplAstNode && isTwoWayBindingNode(this.activeTmplAstNode)));
-        this._checkAccessViaTemplateTypeCheckBlock(ast, isWrite) ||
-            this._checkAccessViaOwningComponentClassType(ast, isWrite);
+        this._checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) ||
+            this._checkAccessViaOwningComponentClassType(ast, isWrite, astPath);
     }
     /**
      * Checks whether the node refers to an input using the TCB information.
      * Type check block may not exist for e.g. test components, so this can return `null`.
      */
-    _checkAccessViaTemplateTypeCheckBlock(ast, isWrite) {
+    _checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) {
         // There might be no template type checker. E.g. if we check host bindings.
         if (this.templateTypeChecker === null) {
             return false;
@@ -30139,6 +30287,7 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
             targetNode: targetInput.node,
             targetField: targetInput,
             read: ast,
+            readAstPath: astPath,
             context: this.activeTmplAstNode,
             isLikelyNarrowed: false,
             isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
@@ -30153,7 +30302,7 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
      * It attempts to resolve references by traversing accesses of the "component class" type.
      * e.g. `this.bla` is resolved via `CompType#bla` and further.
      */
-    _checkAccessViaOwningComponentClassType(ast, isWrite) {
+    _checkAccessViaOwningComponentClassType(ast, isWrite, astPath) {
         // We might check host bindings, which can never point to template variables or local refs.
         const expressionTemplateTarget = this.templateTypeChecker === null
             ? null
@@ -30176,6 +30325,7 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
             targetNode: matchingTarget.node,
             targetField: matchingTarget,
             read: ast,
+            readAstPath: astPath,
             context: this.activeTmplAstNode,
             isLikelyNarrowed: false,
             isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
@@ -30326,6 +30476,7 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
             kind: ReferenceKind.InHostBinding,
             from: {
                 read: ref.read,
+                readAstPath: ref.readAstPath,
                 isObjectShorthandExpression: ref.isObjectShorthandExpression,
                 isWrite: ref.isWrite,
                 file: projectFile(ref.context.getSourceFile(), programInfo),
@@ -30425,6 +30576,7 @@ function identifyTemplateReferences(programInfo, node, reflector, checker$1, eva
                 kind: ReferenceKind.InTemplate,
                 from: {
                     read: res.read,
+                    readAstPath: res.readAstPath,
                     node: res.context,
                     isObjectShorthandExpression: res.isObjectShorthandExpression,
                     originatingTsFile: projectFile(node.getSourceFile(), programInfo),
@@ -30546,12 +30698,16 @@ const writeBinaryOperators = [
 /**
  * Checks whether given TypeScript reference refers to an Angular input, and captures
  * the reference if possible.
+ *
+ * @param fieldNamesToConsiderForReferenceLookup List of field names that should be
+ *   respected when expensively looking up references to known fields.
+ *   May be null if all identifiers should be inspected.
  */
-function identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, advisors) {
+function identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, fieldNamesToConsiderForReferenceLookup, advisors) {
     // Skip all identifiers that never can point to a migrated field.
     // TODO: Capture these assumptions and performance optimizations in the design doc.
-    if (knownFields.fieldNamesToConsiderForReferenceLookup !== null &&
-        !knownFields.fieldNamesToConsiderForReferenceLookup.has(node.text)) {
+    if (fieldNamesToConsiderForReferenceLookup !== null &&
+        !fieldNamesToConsiderForReferenceLookup.has(node.text)) {
         return;
     }
     let target = undefined;
@@ -30626,7 +30782,7 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
  *    - Angular templates (inline or external)
  *    - Host binding expressions.
  */
-function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownFields, result) {
+function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownFields, fieldNamesToConsiderForReferenceLookup, result) {
     const debugElComponentInstanceTracker = new DebugElementComponentInstance(checker);
     const partialDirectiveCatalystTracker = new PartialDirectiveTypeInCatalystTests(checker, knownFields);
     const perfCounters = {
@@ -30635,26 +30791,28 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
         tsReferences: 0,
         tsTypes: 0,
     };
+    // Schematic NodeJS execution may not have `global.performance` defined.
+    const currentTimeInMs = () => typeof global.performance !== 'undefined' ? global.performance.now() : Date.now();
     const visitor = (node) => {
-        let lastTime = performance.now();
+        let lastTime = currentTimeInMs();
         if (ts__default["default"].isClassDeclaration(node)) {
             identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, programInfo.userOptions, result, knownFields);
-            perfCounters.template += (performance.now() - lastTime) / 1000;
-            lastTime = performance.now();
+            perfCounters.template += (currentTimeInMs() - lastTime) / 1000;
+            lastTime = currentTimeInMs();
             identifyHostBindingReferences(node, programInfo, checker, reflector, result, knownFields);
-            perfCounters.hostBindings += (performance.now() - lastTime) / 1000;
-            lastTime = performance.now();
+            perfCounters.hostBindings += (currentTimeInMs() - lastTime) / 1000;
+            lastTime = currentTimeInMs();
         }
-        lastTime = performance.now();
+        lastTime = currentTimeInMs();
         // find references, but do not capture input declarations itself.
         if (ts__default["default"].isIdentifier(node) &&
             !(isInputContainerNode(node.parent) && node.parent.name === node)) {
-            identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, {
+            identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, fieldNamesToConsiderForReferenceLookup, {
                 debugElComponentInstanceTracker,
             });
         }
-        perfCounters.tsReferences += (performance.now() - lastTime) / 1000;
-        lastTime = performance.now();
+        perfCounters.tsReferences += (currentTimeInMs() - lastTime) / 1000;
+        lastTime = currentTimeInMs();
         // Detect `Partial<T>` references.
         // Those are relevant to be tracked as they may be updated in Catalyst to
         // unwrap signal inputs. Commonly people use `Partial` in Catalyst to type
@@ -30672,7 +30830,7 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
                 target: partialDirectiveInCatalyst.targetClass,
             });
         }
-        perfCounters.tsTypes += (performance.now() - lastTime) / 1000;
+        perfCounters.tsTypes += (currentTimeInMs() - lastTime) / 1000;
     };
     return {
         visitor,
@@ -30692,8 +30850,8 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
  * In addition, spying onto an input may be problematic- so we skip migrating
  * such.
  */
-function pass2_IdentifySourceFileReferences(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, groupedTsAstVisitor, knownInputs, result) {
-    groupedTsAstVisitor.register(createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownInputs, result).visitor);
+function pass2_IdentifySourceFileReferences(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, groupedTsAstVisitor, knownInputs, result, fieldNamesToConsiderForReferenceLookup) {
+    groupedTsAstVisitor.register(createFindAllSourceFileReferencesVisitor(programInfo, checker, reflector, resourceLoader, evaluator, templateTypeChecker, knownInputs, fieldNamesToConsiderForReferenceLookup, result).visitor);
 }
 
 /** Gets all types that are inherited (implemented or extended). */
@@ -30722,14 +30880,18 @@ class InheritanceGraph {
     constructor(checker) {
         this.checker = checker;
         /** Maps nodes to their parent nodes. */
-        this.classParents = new Map();
+        this.classToParents = new Map();
         /** Maps nodes to their derived nodes. */
         this.parentToChildren = new Map();
+        /** All classes seen participating in inheritance chains. */
+        this.allClassesInInheritance = new Set();
     }
     /** Registers a given class in the graph. */
     registerClass(clazz, parents) {
-        this.classParents.set(clazz, parents);
+        this.classToParents.set(clazz, parents);
+        this.allClassesInInheritance.add(clazz);
         for (const parent of parents) {
+            this.allClassesInInheritance.add(parent);
             if (!this.parentToChildren.has(parent)) {
                 this.parentToChildren.set(parent, []);
             }
@@ -30743,7 +30905,7 @@ class InheritanceGraph {
      * @returns Symbols of the inherited or derived members, if they exist.
      */
     checkOverlappingMembers(clazz, member, memberName) {
-        const inheritedTypes = (this.classParents.get(clazz) ?? []).map((c) => this.checker.getTypeAtLocation(c));
+        const inheritedTypes = (this.classToParents.get(clazz) ?? []).map((c) => this.checker.getTypeAtLocation(c));
         const derivedLeafs = this._traceDerivedChainToLeafs(clazz).map((c) => this.checker.getTypeAtLocation(c));
         const inheritedMember = inheritedTypes
             .map((t) => t.getProperty(memberName))
@@ -30874,12 +31036,19 @@ function executeAnalysisPhase(host, knownInputs, result, { sourceFiles, fullProg
     // e.g. `ngtypecheck` files.
     !checker.isShim(sf) &&
         pass1__IdentifySourceFileAndDeclarationInputs(sf, host, typeChecker, reflector, dtsMetadataReader, evaluator, refEmitter, knownInputs, result));
+    const fieldNamesToConsiderForReferenceLookup = new Set();
+    for (const input of knownInputs.knownInputIds.values()) {
+        if (host.config.shouldMigrateInput?.(input) === false) {
+            continue;
+        }
+        fieldNamesToConsiderForReferenceLookup.add(input.descriptor.node.name.text);
+    }
     // A graph starting with source files is sufficient. We will resolve into
     // declaration files if a source file depends on such.
     const inheritanceGraph = new InheritanceGraph(typeChecker).expensivePopulate(sourceFiles);
     const pass2And3SourceFileVisitor = new GroupedTsAstVisitor(sourceFiles);
     // Register pass 2. Find all source file references.
-    pass2_IdentifySourceFileReferences(host.programInfo, typeChecker, reflector, resourceLoader, evaluator, templateTypeChecker, pass2And3SourceFileVisitor, knownInputs, result);
+    pass2_IdentifySourceFileReferences(host.programInfo, typeChecker, reflector, resourceLoader, evaluator, templateTypeChecker, pass2And3SourceFileVisitor, knownInputs, result, fieldNamesToConsiderForReferenceLookup);
     // Register pass 3. Check incompatible patterns pass.
     pass3__checkIncompatiblePatterns(inheritanceGraph, typeChecker, pass2And3SourceFileVisitor, knownInputs);
     // Perform Pass 2 and Pass 3, efficiently in one pass.
@@ -30915,44 +31084,6 @@ function executeAnalysisPhase(host, knownInputs, result, { sourceFiles, fullProg
     return { inheritanceGraph };
 }
 
-/**
- * Sorts the inheritance graph topologically, so that
- * classes without incoming edges are returned first.
- *
- * I.e. The returned list is sorted, so that dependencies
- * of a given class are guaranteed to be included at
- * an earlier position than the inspected class.
- *
- * This sort is helpful for detecting inheritance problems
- * for the migration in simpler ways, without having to
- * check in both directions (base classes, and derived classes).
- */
-function topologicalSort(graph) {
-    // All classes without incoming edges.
-    const S = Array.from(graph.classParents.keys()).filter((n) => !graph.parentToChildren.has(n) || graph.parentToChildren.get(n).length === 0);
-    const result = [];
-    const classParents = new Map(graph.classParents);
-    const parentToChildren = new Map(graph.parentToChildren);
-    while (S.length) {
-        const node = S.pop();
-        result.push(node);
-        for (const next of classParents.get(node) ?? []) {
-            // Remove edge from "node -> next".
-            classParents.set(node, classParents.get(node).filter((n) => n !== next));
-            // Remove edge from "next -> node". Do not modify original array as it might
-            // be the one from the original graph
-            const newParentToChildrenForNext = [...parentToChildren.get(next)];
-            newParentToChildrenForNext.splice(newParentToChildrenForNext.indexOf(node), 1);
-            parentToChildren.set(next, newParentToChildrenForNext);
-            // if there are no incoming edges for `next`. add it to `S`.
-            if (parentToChildren.get(next).length === 0) {
-                S.push(next);
-            }
-        }
-    }
-    return result;
-}
-
 /**
  * Phase that propagates incompatibilities to derived classes or
  * base classes. For example, consider:
@@ -30974,14 +31105,8 @@ function topologicalSort(graph) {
  * would then have other derived classes as well, it would propagate the status.
  */
 function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, opts) {
-    // Sort topologically and iterate super classes first, so that we can trivially
-    // propagate incompatibility statuses (and other checks) without having to check
-    // in both directions (derived classes, or base classes). This simplifies the logic
-    // further down in this function significantly.
-    const topologicalSortedClasses = topologicalSort(inheritanceGraph)
-        .filter((t) => ts__default["default"].isClassDeclaration(t) && opts.isClassWithKnownFields(t))
-        .reverse();
-    for (const inputClass of topologicalSortedClasses) {
+    const allInputClasses = Array.from(inheritanceGraph.allClassesInInheritance).filter((t) => ts__default["default"].isClassDeclaration(t) && opts.isClassWithKnownFields(t));
+    for (const inputClass of allInputClasses) {
         // Note: Class parents of `inputClass` were already checked by
         // the previous iterations (given the reverse topological sort)—
         // hence it's safe to assume that incompatibility of parent classes will
@@ -31009,22 +31134,18 @@ function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, o
             if (fieldDescr.node.name !== undefined &&
                 (ts__default["default"].isIdentifier(fieldDescr.node.name) || ts__default["default"].isStringLiteralLike(fieldDescr.node.name)) &&
                 inputFieldNamesFromMetadataArray.has(fieldDescr.node.name.text)) {
-                fields.markFieldIncompatible(fieldDescr, {
-                    context: null,
-                    reason: InputIncompatibilityReason.RedeclaredViaDerivedClassInputsArray,
-                });
+                fields.captureUnknownDerivedField(fieldDescr);
             }
             for (const derived of derivedMembers) {
                 const derivedInput = fields.attemptRetrieveDescriptorFromSymbol(derived);
                 if (derivedInput !== null) {
+                    // Note: We always track dependencies from the child to the parent,
+                    // so skip here for now.
                     continue;
                 }
                 // If we discover a derived, non-input member, then it will cause
                 // conflicts, and we mark the current input as incompatible.
-                fields.markFieldIncompatible(fieldDescr, {
-                    context: derived.valueDeclaration ?? inputNode,
-                    reason: InputIncompatibilityReason.OverriddenByDerivedClass,
-                });
+                fields.captureUnknownDerivedField(fieldDescr);
                 continue inputCheck;
             }
             // If there is no parent, we are done. Otherwise, check the parent
@@ -31035,21 +31156,10 @@ function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, o
             const inheritedMemberInput = fields.attemptRetrieveDescriptorFromSymbol(inherited);
             // Parent is not an input, and hence will conflict..
             if (inheritedMemberInput === null) {
-                fields.markFieldIncompatible(fieldDescr, {
-                    context: inherited.valueDeclaration ?? inputNode,
-                    reason: InputIncompatibilityReason.TypeConflictWithBaseClass,
-                });
-                continue;
-            }
-            // Parent is incompatible, so this input also needs to be.
-            // It cannot be migrated.
-            if (fields.isFieldIncompatible(inheritedMemberInput)) {
-                fields.markFieldIncompatible(fieldDescr, {
-                    context: inheritedMemberInput.node,
-                    reason: InputIncompatibilityReason.ParentIsIncompatible,
-                });
+                fields.captureUnknownParentField(fieldDescr);
                 continue;
             }
+            fields.captureKnownFieldInheritanceRelationship(fieldDescr, inheritedMemberInput);
         }
     }
 }
@@ -31085,134 +31195,156 @@ function pass4__checkInheritanceOfInputs(inheritanceGraph, metaRegistry, knownIn
     });
 }
 
-/** Type of incompatibility. */
-var IncompatibilityType;
-(function (IncompatibilityType) {
-    IncompatibilityType[IncompatibilityType["VIA_CLASS"] = 0] = "VIA_CLASS";
-    IncompatibilityType[IncompatibilityType["VIA_INPUT"] = 1] = "VIA_INPUT";
-})(IncompatibilityType || (IncompatibilityType = {}));
-
-function getCompilationUnitMetadata(knownInputs, result) {
+function getCompilationUnitMetadata(knownInputs) {
     const struct = {
         knownInputs: Array.from(knownInputs.knownInputIds.entries()).reduce((res, [inputClassFieldIdStr, info]) => {
-            const classIncompatibility = info.container.incompatible !== null
-                ? { kind: IncompatibilityType.VIA_CLASS, reason: info.container.incompatible }
-                : null;
+            const classIncompatibility = info.container.incompatible !== null ? info.container.incompatible : null;
             const memberIncompatibility = info.container.memberIncompatibility.has(inputClassFieldIdStr)
-                ? {
-                    kind: IncompatibilityType.VIA_INPUT,
-                    reason: info.container.memberIncompatibility.get(inputClassFieldIdStr).reason,
-                }
+                ? info.container.memberIncompatibility.get(inputClassFieldIdStr).reason
                 : null;
-            const incompatibility = classIncompatibility ?? memberIncompatibility ?? null;
             // Note: Trim off the `context` as it cannot be serialized with e.g. TS nodes.
             return {
                 ...res,
                 [inputClassFieldIdStr]: {
-                    isIncompatible: incompatibility,
+                    owningClassIncompatibility: classIncompatibility,
+                    memberIncompatibility,
+                    seenAsSourceInput: info.metadata.inSourceFile,
+                    extendsFrom: info.extendsFrom?.key ?? null,
                 },
             };
         }, {}),
-        references: result.references.map((r) => {
-            if (isTsReference(r)) {
-                return {
-                    kind: r.kind,
-                    target: r.target.key,
-                    from: {
-                        file: r.from.file,
-                        node: { positionEndInFile: r.from.node.getEnd() },
-                        isWrite: r.from.isWrite,
-                        isPartOfElementBinding: r.from.isPartOfElementBinding,
-                    },
-                };
-            }
-            else if (isHostBindingReference(r)) {
-                return {
-                    kind: r.kind,
-                    target: r.target.key,
-                    from: {
-                        file: r.from.file,
-                        hostPropertyNode: { positionEndInFile: r.from.hostPropertyNode.getEnd() },
-                        isObjectShorthandExpression: r.from.isObjectShorthandExpression,
-                        isWrite: r.from.isWrite,
-                        read: { positionEndInFile: r.from.read.sourceSpan.end },
-                    },
-                };
-            }
-            else if (isTsClassTypeReference(r)) {
-                return {
-                    kind: r.kind,
-                    target: { positionEndInFile: r.target.getEnd() },
-                    from: {
-                        file: r.from.file,
-                        node: { positionEndInFile: r.from.node.getEnd() },
-                    },
-                    isPartOfCatalystFile: r.isPartOfCatalystFile,
-                    isPartialReference: r.isPartialReference,
-                };
-            }
-            return {
-                kind: r.kind,
-                target: r.target.key,
-                from: {
-                    originatingTsFile: r.from.originatingTsFile,
-                    templateFile: r.from.templateFile,
-                    isObjectShorthandExpression: r.from.isObjectShorthandExpression,
-                    isLikelyPartOfNarrowing: r.from.isLikelyPartOfNarrowing,
-                    isWrite: r.from.isWrite,
-                    node: { positionEndInFile: r.from.node.sourceSpan.end.offset },
-                    read: { positionEndInFile: r.from.read.sourceSpan.end },
-                },
-            };
-        }),
     };
     return struct;
 }
 
+/**
+ * Sorts the inheritance graph topologically, so that
+ * nodes without incoming edges are returned first.
+ *
+ * I.e. The returned list is sorted, so that dependencies
+ * of a given class are guaranteed to be included at
+ * an earlier position than the inspected class.
+ *
+ * This sort is helpful for detecting inheritance problems
+ * for the migration in simpler ways, without having to
+ * check in both directions (base classes, and derived classes).
+ */
+function topologicalSort(graph) {
+    // All nodes without incoming edges.
+    const S = graph.filter((n) => n.incoming.size === 0);
+    const result = [];
+    const invalidatedEdges = new WeakMap();
+    const invalidateEdge = (from, to) => {
+        if (!invalidatedEdges.has(from)) {
+            invalidatedEdges.set(from, new Set());
+        }
+        invalidatedEdges.get(from).add(to);
+    };
+    const filterEdges = (from, edges) => {
+        return Array.from(edges).filter((e) => !invalidatedEdges.has(from) || !invalidatedEdges.get(from).has(e));
+    };
+    while (S.length) {
+        const node = S.pop();
+        result.push(node);
+        for (const next of filterEdges(node, node.outgoing)) {
+            // Remove edge from "node -> next".
+            invalidateEdge(node, next);
+            // Remove edge from "next -> node".
+            invalidateEdge(next, node);
+            // if there are no incoming edges for `next`. add it to `S`.
+            if (filterEdges(next, next.incoming).length === 0) {
+                S.push(next);
+            }
+        }
+    }
+    return result;
+}
+
 /** Merges a list of compilation units into a combined unit. */
 function mergeCompilationUnitData(metadataFiles) {
     const result = {
         knownInputs: {},
-        references: [],
     };
-    const seenReferenceFromIds = new Set();
+    const idToGraphNode = new Map();
+    const inheritanceGraph = [];
+    const isNodeIncompatible = (node) => node.info.memberIncompatibility !== null || node.info.owningClassIncompatibility !== null;
     for (const file of metadataFiles) {
         for (const [key, info] of Object.entries(file.knownInputs)) {
             const existing = result.knownInputs[key];
             if (existing === undefined) {
                 result.knownInputs[key] = info;
+                const node = {
+                    incoming: new Set(),
+                    outgoing: new Set(),
+                    data: { info, key },
+                };
+                inheritanceGraph.push(node);
+                idToGraphNode.set(key, node);
+                continue;
             }
-            else if (existing.isIncompatible === null && info.isIncompatible) {
-                // input might not be incompatible in one target, but others might invalidate it.
-                // merge the incompatibility state.
-                existing.isIncompatible = info.isIncompatible;
+            // Merge metadata.
+            if (existing.extendsFrom === null && info.extendsFrom !== null) {
+                existing.extendsFrom = info.extendsFrom;
             }
-        }
-        for (const reference of file.references) {
-            const referenceId = computeReferenceId(reference);
-            if (seenReferenceFromIds.has(referenceId)) {
-                continue;
+            if (!existing.seenAsSourceInput && info.seenAsSourceInput) {
+                existing.seenAsSourceInput = true;
+            }
+            // Merge member incompatibility.
+            if (info.memberIncompatibility !== null) {
+                if (existing.memberIncompatibility === null) {
+                    existing.memberIncompatibility = info.memberIncompatibility;
+                }
+                else {
+                    // Input might not be incompatible in one target, but others might invalidate it.
+                    // merge the incompatibility state.
+                    existing.memberIncompatibility = pickInputIncompatibility({ reason: info.memberIncompatibility, context: null }, { reason: existing.memberIncompatibility, context: null }).reason;
+                }
+            }
+            // Merge incompatibility of the class owning the input.
+            // Note: This metadata is stored per field for simplicity currently,
+            // but in practice it could be a separate field in the compilation data.
+            if (info.owningClassIncompatibility !== null &&
+                existing.owningClassIncompatibility === null) {
+                existing.owningClassIncompatibility = info.owningClassIncompatibility;
             }
-            seenReferenceFromIds.add(referenceId);
-            result.references.push(reference);
         }
     }
-    return result;
-}
-/** Computes a unique ID for the given reference. */
-function computeReferenceId(reference) {
-    if (reference.kind === ReferenceKind.InTemplate) {
-        return `${reference.from.templateFile.id}@@${reference.from.read.positionEndInFile}`;
+    for (const [key, info] of Object.entries(result.knownInputs)) {
+        if (info.extendsFrom !== null) {
+            const from = idToGraphNode.get(key);
+            const target = idToGraphNode.get(info.extendsFrom);
+            from.outgoing.add(target);
+            target.incoming.add(from);
+        }
     }
-    else if (reference.kind === ReferenceKind.InHostBinding) {
-        // `read` position is commonly relative to the host property node position— so we need
-        // to make it absolute by incorporating the host node position.
-        return (`${reference.from.file.id}@@${reference.from.hostPropertyNode.positionEndInFile}` +
-            `@@${reference.from.read.positionEndInFile}`);
+    // Sort topologically and iterate super classes first, so that we can trivially
+    // propagate incompatibility statuses (and other checks) without having to check
+    // in both directions (derived classes, or base classes). This simplifies the
+    // propagation.
+    for (const node of topologicalSort(inheritanceGraph).reverse()) {
+        const existingMemberIncompatibility = node.data.info.memberIncompatibility !== null
+            ? { reason: node.data.info.memberIncompatibility, context: null }
+            : null;
+        for (const parent of node.outgoing) {
+            // If parent is incompatible and not migrated, then this input
+            // cannot be migrated either. Try propagating parent incompatibility then.
+            if (isNodeIncompatible(parent.data)) {
+                node.data.info.memberIncompatibility = pickInputIncompatibility({ reason: InputIncompatibilityReason.ParentIsIncompatible, context: null }, existingMemberIncompatibility).reason;
+                break;
+            }
+        }
     }
-    else {
-        return `${reference.from.file.id}@@${reference.from.node.positionEndInFile}`;
+    for (const info of Object.values(result.knownInputs)) {
+        // We never saw a source file for this input, globally. Try marking it as incompatible,
+        // so that all references and inheritance checks can propagate accordingly.
+        if (!info.seenAsSourceInput) {
+            const existingMemberIncompatibility = info.memberIncompatibility !== null
+                ? { reason: info.memberIncompatibility, context: null }
+                : null;
+            info.memberIncompatibility = pickInputIncompatibility({ reason: InputIncompatibilityReason.OutsideOfMigrationScope, context: null }, existingMemberIncompatibility).reason;
+        }
     }
+    return result;
 }
 
 function populateKnownInputsFromGlobalData(knownInputs, globalData) {
@@ -31224,16 +31356,14 @@ function populateKnownInputsFromGlobalData(knownInputs, globalData) {
             continue;
         }
         const inputMetadata = knownInputs.get({ key });
-        if (!inputMetadata.isIncompatible() && info.isIncompatible) {
-            if (info.isIncompatible.kind === IncompatibilityType.VIA_CLASS) {
-                knownInputs.markClassIncompatible(inputMetadata.container.clazz, info.isIncompatible.reason);
-            }
-            else {
-                knownInputs.markFieldIncompatible(inputMetadata.descriptor, {
-                    context: null, // No context serializable.
-                    reason: info.isIncompatible.reason,
-                });
-            }
+        if (info.memberIncompatibility) {
+            knownInputs.markFieldIncompatible(inputMetadata.descriptor, {
+                context: null, // No context serializable.
+                reason: info.memberIncompatibility,
+            });
+        }
+        if (info.owningClassIncompatibility) {
+            knownInputs.markClassIncompatible(inputMetadata.container.clazz, info.owningClassIncompatibility);
         }
     }
 }
@@ -31250,15 +31380,54 @@ function removeFromUnionIfPossible(union, filter) {
     return ts__default["default"].factory.updateUnionTypeNode(union, ts__default["default"].factory.createNodeArray(filtered));
 }
 
+/**
+ * Inserts a leading string for the given node, respecting
+ * indentation of the given anchor node.
+ *
+ * Useful for inserting TODOs.
+ */
+function insertPrecedingLine(node, info, text) {
+    const leadingSpace = leading_space.getLeadingLineWhitespaceOfNode(node);
+    return new Replacement(projectFile(node.getSourceFile(), info), new TextUpdate({
+        position: node.getStart(),
+        end: node.getStart(),
+        toInsert: `${text}\n${leadingSpace}`,
+    }));
+}
+
+/**
+ * Cuts the given string into lines basing around the specified
+ * line length limit. This function breaks the string on a per-word basis.
+ */
+function cutStringToLineLimit(str, limit) {
+    const words = str.split(' ');
+    const chunks = [];
+    let chunkIdx = 0;
+    while (words.length) {
+        // New line if we exceed limit.
+        if (chunks[chunkIdx] !== undefined && chunks[chunkIdx].length > limit) {
+            chunkIdx++;
+        }
+        // Ensure line is initialized for the given index.
+        if (chunks[chunkIdx] === undefined) {
+            chunks[chunkIdx] = '';
+        }
+        const word = words.shift();
+        const needsSpace = chunks[chunkIdx].length > 0;
+        // Insert word. Add space before, if the line already contains text.
+        chunks[chunkIdx] += `${needsSpace ? ' ' : ''}${word}`;
+    }
+    return chunks;
+}
+
 // TODO: Consider initializations inside the constructor. Those are not migrated right now
 // though, as they are writes.
 /**
- *
  * Converts an `@Input()` property declaration to a signal input.
  *
- * @returns The transformed property declaration, printed as a string.
+ * @returns Replacements for converting the input.
  */
-function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType, preferShorthandIfPossible, originalInputDecorator, initialValue, }, checker, importManager, result) {
+function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType, preferShorthandIfPossible, originalInputDecorator, initialValue, leadingTodoText, }, info, checker, importManager, result) {
     let optionsLiteral = null;
     // We need an options array for the input because:
     //   - the input is either aliased,
@@ -31269,7 +31438,13 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
             properties.push(ts__default["default"].factory.createPropertyAssignment('alias', ts__default["default"].factory.createStringLiteral(metadata.bindingPropertyName)));
         }
         if (metadata.transform !== null) {
-            properties.push(extractTransformOfInput(metadata.transform, resolvedType, checker));
+            const transformRes = extractTransformOfInput(metadata.transform, resolvedType, checker);
+            properties.push(transformRes.node);
+            // Propagate TODO if one was requested from the transform extraction/validation.
+            if (transformRes.leadingTodoText !== null) {
+                leadingTodoText =
+                    (leadingTodoText ? `${leadingTodoText} ` : '') + transformRes.leadingTodoText;
+            }
         }
         optionsLiteral = ts__default["default"].factory.createObjectLiteralExpression(properties);
     }
@@ -31323,7 +31498,17 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
         modifiersWithoutInputDecorator.push(ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword));
     }
     const newNode = ts__default["default"].factory.createPropertyDeclaration(modifiersWithoutInputDecorator, node.name, undefined, undefined, inputInitializer);
-    return result.printer.printNode(ts__default["default"].EmitHint.Unspecified, newNode, node.getSourceFile());
+    const newPropertyText = result.printer.printNode(ts__default["default"].EmitHint.Unspecified, newNode, node.getSourceFile());
+    const replacements = [];
+    if (leadingTodoText !== null) {
+        replacements.push(insertPrecedingLine(node, info, '// TODO: Notes from signal input migration:'), ...cutStringToLineLimit(leadingTodoText, 70).map((line) => insertPrecedingLine(node, info, `//  ${line}`)));
+    }
+    replacements.push(new Replacement(projectFile(node.getSourceFile(), info), new TextUpdate({
+        position: node.getStart(),
+        end: node.getEnd(),
+        toInsert: newPropertyText,
+    })));
+    return replacements;
 }
 /**
  * Extracts the transform for the given input and returns a property assignment
@@ -31332,10 +31517,11 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
 function extractTransformOfInput(transform, resolvedType, checker) {
     assert__default["default"](ts__default["default"].isExpression(transform.node), `Expected transform to be an expression.`);
     let transformFn = transform.node;
+    let leadingTodoText = null;
     // If there is an explicit type, check if the transform return type actually works.
     // In some cases, the transform function is not compatible because with decorator inputs,
     // those were not checked. We cast the transform to `any` and add a TODO.
-    // TODO: Insert a TODO and capture this in the design doc.
+    // TODO: Capture this in the design doc.
     if (resolvedType !== undefined && !ts__default["default"].isSyntheticExpression(resolvedType)) {
         // Note: If the type is synthetic, we cannot check, and we accept that in the worst case
         // we will create code that is not necessarily compiling. This is unlikely, but notably
@@ -31344,33 +31530,67 @@ function extractTransformOfInput(transform, resolvedType, checker) {
         const transformSignature = transformType.getCallSignatures()[0];
         assert__default["default"](transformSignature !== undefined, 'Expected transform to be an invoke-able.');
         if (!checker.isTypeAssignableTo(checker.getReturnTypeOfSignature(transformSignature), checker.getTypeFromTypeNode(resolvedType))) {
+            leadingTodoText =
+                'Input type is incompatible with transform. The migration added an `any` cast. ' +
+                    'This worked previously because Angular was unable to check transforms.';
             transformFn = ts__default["default"].factory.createAsExpression(ts__default["default"].factory.createParenthesizedExpression(transformFn), ts__default["default"].factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.AnyKeyword));
         }
     }
-    return ts__default["default"].factory.createPropertyAssignment('transform', transformFn);
+    return {
+        node: ts__default["default"].factory.createPropertyAssignment('transform', transformFn),
+        leadingTodoText,
+    };
+}
+
+/**
+ * Inserts a TODO for the incompatibility blocking the given node
+ * from being migrated.
+ */
+function insertTodoForIncompatibility(node, programInfo, input) {
+    const incompatibility = input.container.getInputMemberIncompatibility(input.descriptor);
+    if (incompatibility === null) {
+        return [];
+    }
+    // If an input is skipped via config filter or outside migration scope, do not
+    // insert TODOs, as this could results in lots of unnecessary comments.
+    if (isInputMemberIncompatibility(incompatibility) &&
+        (incompatibility.reason === InputIncompatibilityReason.SkippedViaConfigFilter ||
+            incompatibility.reason === InputIncompatibilityReason.OutsideOfMigrationScope)) {
+        return [];
+    }
+    const message = isInputMemberIncompatibility(incompatibility)
+        ? getMessageForInputIncompatibility(incompatibility.reason).short
+        : getMessageForClassIncompatibility(incompatibility).short;
+    const lines = cutStringToLineLimit(message, 70);
+    return [
+        insertPrecedingLine(node, programInfo, `// TODO: Skipped for migration because:`),
+        ...lines.map((line) => insertPrecedingLine(node, programInfo, `//  ${line}`)),
+    ];
 }
 
 /**
  * Phase that migrates `@Input()` declarations to signal inputs and
  * manages imports within the given file.
  */
-function pass6__migrateInputDeclarations(checker, result, knownInputs, importManager, info) {
+function pass6__migrateInputDeclarations(host, checker, result, knownInputs, importManager, info) {
     let filesWithMigratedInputs = new Set();
     let filesWithIncompatibleInputs = new WeakSet();
     for (const [input, metadata] of result.sourceInputs) {
         const sf = input.node.getSourceFile();
+        const inputInfo = knownInputs.get(input);
         // Do not migrate incompatible inputs.
-        if (knownInputs.get(input).isIncompatible() || metadata === null) {
+        if (inputInfo.isIncompatible()) {
+            // Add a TODO for the incompatible input, if desired.
+            if (host.config.insertTodosForSkippedFields) {
+                result.replacements.push(...insertTodoForIncompatibility(input.node, info, inputInfo));
+            }
             filesWithIncompatibleInputs.add(sf);
             continue;
         }
+        assert__default["default"](metadata !== null, `Expected metadata to exist for input isn't marked incompatible.`);
         assert__default["default"](!ts__default["default"].isAccessor(input.node), 'Accessor inputs are incompatible.');
         filesWithMigratedInputs.add(sf);
-        result.replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
-            position: input.node.getStart(),
-            end: input.node.getEnd(),
-            toInsert: convertToSignalInput(input.node, metadata, checker, importManager, result),
-        })));
+        result.replacements.push(...convertToSignalInput(input.node, metadata, info, checker, importManager, result));
     }
     for (const file of filesWithMigratedInputs) {
         // All inputs were migrated, so we can safely remove the `Input` symbol.
@@ -32353,7 +32573,7 @@ function executeMigrationPhase(host, knownInputs, result, info) {
     };
     // Migrate passes.
     pass5__migrateTypeScriptReferences(referenceMigrationHost, result.references, typeChecker, info);
-    pass6__migrateInputDeclarations(typeChecker, result, knownInputs, importManager, info);
+    pass6__migrateInputDeclarations(host, typeChecker, result, knownInputs, importManager, info);
     pass7__migrateTemplateReferences(referenceMigrationHost, result.references);
     pass8__migrateHostBindings(referenceMigrationHost, result.references, info);
     pass9__migrateTypeScriptTypeReferences(referenceMigrationHost, result.references, importManager, info);
@@ -32362,6 +32582,8 @@ function executeMigrationPhase(host, knownInputs, result, info) {
 
 /** Input reasons that cannot be ignored. */
 const nonIgnorableInputIncompatibilities = [
+    // Outside of scope inputs should not be migrated. E.g. references to inputs in `node_modules/`.
+    InputIncompatibilityReason.OutsideOfMigrationScope,
     // Explicitly filtered inputs cannot be skipped via best effort mode.
     InputIncompatibilityReason.SkippedViaConfigFilter,
     // There is no good output for accessor inputs.
@@ -32404,48 +32626,59 @@ class SignalInputMigration extends TsurgeComplexMigration {
             strictTemplates: true,
         });
     }
-    // Extend the program info with the analysis information we need in every phase.
-    prepareAnalysisDeps(info) {
-        assert__default["default"](info.ngCompiler !== null, 'Expected `NgCompiler` to be configured.');
-        const analysisInfo = {
-            ...info,
-            ...prepareAnalysisInfo(info.program, info.ngCompiler, info.programAbsoluteRootFileNames),
-        };
+    prepareProgram(baseInfo) {
+        const info = super.prepareProgram(baseInfo);
         // Optional filter for testing. Allows for simulation of parallel execution
         // even if some tsconfig's have overlap due to sharing of TS sources.
         // (this is commonly not the case in g3 where deps are `.d.ts` files).
         const limitToRootNamesOnly = process.env['LIMIT_TO_ROOT_NAMES_ONLY'] === '1';
-        analysisInfo.sourceFiles = analysisInfo.sourceFiles.filter((f) => 
+        const filteredSourceFiles = info.sourceFiles.filter((f) => 
         // Optional replacement filter. Allows parallel execution in case
         // some tsconfig's have overlap due to sharing of TS sources.
         // (this is commonly not the case in g3 where deps are `.d.ts` files).
         !limitToRootNamesOnly || info.programAbsoluteRootFileNames.includes(f.fileName));
+        return {
+            ...info,
+            sourceFiles: filteredSourceFiles,
+        };
+    }
+    // Extend the program info with the analysis information we need in every phase.
+    prepareAnalysisDeps(info) {
+        assert__default["default"](info.ngCompiler !== null, 'Expected `NgCompiler` to be configured.');
+        const analysisInfo = {
+            ...info,
+            ...prepareAnalysisInfo(info.program, info.ngCompiler, info.programAbsoluteRootFileNames),
+        };
         return analysisInfo;
     }
     async analyze(info) {
         const analysisDeps = this.prepareAnalysisDeps(info);
-        const { metaRegistry } = analysisDeps;
         const knownInputs = new KnownInputs(info, this.config);
         const result = new MigrationResult();
         const host = createMigrationHost(info, this.config);
         this.config.reportProgressFn?.(10, 'Analyzing project (input usages)..');
         const { inheritanceGraph } = executeAnalysisPhase(host, knownInputs, result, analysisDeps);
+        // Mark filtered inputs before checking inheritance. This ensures filtered
+        // inputs properly influence e.g. inherited or derived inputs that now wouldn't
+        // be safe either (BUT can still be skipped via best effort mode later).
         filterInputsViaConfig(result, knownInputs, this.config);
+        // Analyze inheritance, track edges etc. and later propagate incompatibilities in
+        // the merge stage.
         this.config.reportProgressFn?.(40, 'Checking inheritance..');
-        pass4__checkInheritanceOfInputs(inheritanceGraph, metaRegistry, knownInputs);
+        pass4__checkInheritanceOfInputs(inheritanceGraph, analysisDeps.metaRegistry, knownInputs);
+        // Filter best effort incompatibilities, so that the new filtered ones can
+        // be accordingly respected in the merge phase.
         if (this.config.bestEffortMode) {
             filterIncompatibilitiesForBestEffortMode(knownInputs);
         }
-        const unitData = getCompilationUnitMetadata(knownInputs, result);
+        const unitData = getCompilationUnitMetadata(knownInputs);
         // Non-batch mode!
         if (this.config.upgradeAnalysisPhaseToAvoidBatch) {
             const merged = await this.merge([unitData]);
-            this.config.reportProgressFn?.(60, 'Collecting migration changes..');
             const replacements = await this.migrate(merged, info, {
                 knownInputs,
                 result,
                 host,
-                inheritanceGraph,
                 analysisDeps,
             });
             this.config.reportProgressFn?.(100, 'Completed migration.');
@@ -32466,18 +32699,16 @@ class SignalInputMigration extends TsurgeComplexMigration {
         const result = nonBatchData?.result ?? new MigrationResult();
         const host = nonBatchData?.host ?? createMigrationHost(info, this.config);
         const analysisDeps = nonBatchData?.analysisDeps ?? this.prepareAnalysisDeps(info);
-        let inheritanceGraph;
         // Can't re-use analysis structures, so re-build them.
         if (nonBatchData === undefined) {
-            const analysisRes = executeAnalysisPhase(host, knownInputs, result, analysisDeps);
-            inheritanceGraph = analysisRes.inheritanceGraph;
-            populateKnownInputsFromGlobalData(knownInputs, globalMetadata);
-            filterInputsViaConfig(result, knownInputs, this.config);
-            pass4__checkInheritanceOfInputs(inheritanceGraph, analysisDeps.metaRegistry, knownInputs);
-            if (this.config.bestEffortMode) {
-                filterIncompatibilitiesForBestEffortMode(knownInputs);
-            }
+            executeAnalysisPhase(host, knownInputs, result, analysisDeps);
+        }
+        // Incorporate global metadata into known inputs.
+        populateKnownInputsFromGlobalData(knownInputs, globalMetadata);
+        if (this.config.bestEffortMode) {
+            filterIncompatibilitiesForBestEffortMode(knownInputs);
         }
+        this.config.reportProgressFn?.(60, 'Collecting migration changes..');
         executeMigrationPhase(host, knownInputs, result, analysisDeps);
         return result.replacements;
     }
@@ -32560,7 +32791,7 @@ class DevkitMigrationFilesystem {
         return true;
     }
     exists(path) {
-        return this.tree.exists(path);
+        return statPath(this.tree, path) !== null;
     }
     readFile(path) {
         return this.tree.readText(path);
@@ -32683,6 +32914,7 @@ function migrate(options) {
         checker.setFileSystem(fs);
         const migration = new SignalInputMigration({
             bestEffortMode: options.bestEffortMode,
+            insertTodosForSkippedFields: options.insertTodos,
             shouldMigrateInput: (input) => {
                 return (input.file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
                     !/(^|\/)node_modules\//.test(input.file.rootRelativePath));
@@ -32691,6 +32923,7 @@ function migrate(options) {
         const analysisPath = fs.resolve(options.analysisDir);
         const unitResults = [];
         const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
+            context.logger.info(`Preparing analysis for: ${tsconfigPath}..`);
             const baseInfo = migration.createProgram(tsconfigPath, fs);
             const info = migration.prepareProgram(baseInfo);
             // Support restricting the analysis to subfolders for larger projects.
@@ -32703,7 +32936,7 @@ function migrate(options) {
         // Analyze phase. Treat all projects as compilation units as
         // this allows us to support references between those.
         for (const { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Analyzing: ${tsconfigPath}..`);
+            context.logger.info(`Scanning for inputs: ${tsconfigPath}..`);
             unitResults.push(await migration.analyze(info));
         }
         context.logger.info(``);