fix(migrations): migrating input with more than 1 usage in a method

When the migration command was run for inputs, if the input had more than one reference in a method the migration would generate incorrect code

Fixes angular#63018

Author: aparzi

packages/core/schematics/migrations/signal-migration/src/passes/reference_migration/helpers/standard_reference.ts

@@ -11,7 +11,7 @@ import {analyzeControlFlow, ControlFlowAnalysisNode} from '../../../flow_analysi
 import {ProgramInfo, projectFile, Replacement, TextUpdate} from '../../../../../../utils/tsurge';
 import {traverseAccess} from '../../../utils/traverse_access';
 import {UniqueNamesGenerator} from '../../../utils/unique_names';
-import {createNewBlockToInsertVariable} from '../helpers/create_block_arrow_function';
+import {createNewBlockToInsertVariable} from './create_block_arrow_function';
 import assert from 'assert';
 
 export interface NarrowableTsReferences {
@@ -123,6 +123,26 @@ export function migrateStandardTsReference(
         replacements.push(
           ...createNewBlockToInsertVariable(parent, filePath, temporaryVariableStr),
         );
+      } else if (
+        ts.isBlock(recommendedNode) &&
+        shouldInsertAtMethodStart(reference, recommendedNode, referenceNodeInBlock)
+      ) {
+        const blockStart = recommendedNode.getStart() + 1;
+        const firstStatement = recommendedNode.statements[0];
+        const leadingSpace = firstStatement
+          ? ts.getLineAndCharacterOfPosition(sf, firstStatement.getStart())
+          : ts.getLineAndCharacterOfPosition(sf, referenceNodeInBlock.getStart());
+
+        replacements.push(
+          new Replacement(
+            filePath,
+            new TextUpdate({
+              position: blockStart,
+              end: blockStart,
+              toInsert: `${' '.repeat(leadingSpace.character)}${temporaryVariableStr}\n${' '.repeat(leadingSpace.character)}`,
+            }),
+          ),
+        );
       } else {
         const leadingSpace = ts.getLineAndCharacterOfPosition(sf, referenceNodeInBlock.getStart());
 
@@ -151,3 +171,49 @@ export function migrateStandardTsReference(
     }
   }
 }
+
+/**
+ * Determines if a temporary variable should be inserted at the start of a method.
+ *
+ * This function performs several checks to ensure it's safe to insert a temporary variable:
+ * 1. Verifies the recommended node is a method declaration block
+ * 2. Ensures all references are contained within the method body
+ * 3. Confirms the reference node is the first statement in the method
+ * 4. Validates the reference node is an expression statement with an assignment operation
+ *
+ * @param references - Object containing the references to be checked
+ * @param recommendedNode - The node where insertion is being considered (must be a method body block)
+ * @param referenceNodeInBlock - The specific node within the block where the reference occurs
+ * @returns `true` if all conditions are met for safe insertion at method start,
+ *          `false` if any condition fails
+ */
+function shouldInsertAtMethodStart(
+  references: NarrowableTsReferences,
+  recommendedNode: ts.Node,
+  referenceNodeInBlock: ts.Node,
+): boolean {
+  if (!ts.isBlock(recommendedNode) || !ts.isMethodDeclaration(recommendedNode.parent)) {
+    return false;
+  }
+
+  const methodBody = recommendedNode;
+  const allReferencesInMethod = references.accesses.every((access) => {
+    let current: ts.Node | undefined = access;
+    while (current && current !== methodBody) {
+      current = current.parent;
+    }
+    return current === methodBody;
+  });
+
+  if (!allReferencesInMethod) {
+    return false;
+  }
+
+  return (
+    methodBody.statements.length > 0 &&
+    ts.isExpressionStatement(referenceNodeInBlock) &&
+    methodBody.statements[0] === referenceNodeInBlock &&
+    ts.isBinaryExpression(referenceNodeInBlock.expression) &&
+    referenceNodeInBlock.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
+  );
+}

packages/core/schematics/test/signals_migration_spec.ts

@@ -122,4 +122,52 @@ describe('combined signals migration', () => {
     `),
     );
   });
+
+  it('should be able to migrate input with more than 1 usage in a method', async () => {
+    writeFile(
+      '/index.ts',
+      `
+      import {Component, Input} from '@angular/core';
+
+      @Component({
+        template: 'it works'
+      })
+      export class TestMigrationComponent {
+        @Input() public model: any;
+
+        public onSaveClick(): void {
+            this.model.requisitionId = 145;
+            this.model.comment = 'value';
+            this.model.status = 8;
+            this.model.finilizeReasonId = 4
+        }
+      }`,
+    );
+
+    await runMigration(['inputs']);
+
+    expect(stripWhitespace(tree.readContent('/index.ts'))).toBe(
+      stripWhitespace(
+        `
+      import {Component, input} from '@angular/core';
+
+      @Component({
+        template: 'it works'
+      })
+      export class TestMigrationComponent {
+        public readonly model = input<any>(undefined);
+
+        public onSaveClick(): void {
+            const model = this.model();
+
+            model.requisitionId = 145;
+            model.comment = 'value';
+            model.status = 8;
+            model.finilizeReasonId = 4
+        }
+      }
+    `,
+      ),
+    );
+  });
 });