fix: reporting variable used in catch block in no-useless-assignment (#19423)

* fix: reporting variable in catch block

* revert change in best-practice.d.ts file

* check variable in stored catch block

* check variable inside catch in varify function

* update JSDoc comments

* apply fix for read references

* revert changes in best-practice.dts

* apply suggestion

* remove space

* use target scopeStack

* ignore assignments in try blocks

* add know limitations section in docs

* only ignore assignment inside try block

* remove space

* Update docs/src/rules/no-useless-assignment.md

Co-authored-by: Nitin Kumar <snitin315@gmail.com>

---------

Co-authored-by: Nitin Kumar <snitin315@gmail.com>

Author: Tanujkanti4441

docs/src/rules/no-useless-assignment.md

@@ -151,6 +151,41 @@ function fn() {
 
 :::
 
+## Known Limitations
+
+This rule does not report certain variable reassignments when they occur inside the `try` block. This is intentional because such assignments may still be observed within the corresponding `catch` block or after the `try-catch` structure, due to potential early exits or error handling logic.
+
+```js
+function foo() {
+    let bar;
+    try {
+        bar = 2;
+        unsafeFn();
+        return { error: undefined };
+    } catch {
+        return { bar }; // `bar` is observed in the catch block
+    }
+}   
+function unsafeFn() {
+    throw new Error();
+}
+
+function foo() {
+    let bar;
+    try {
+        bar = 2; // This assignment is relevant if unsafeFn() throws an error
+        unsafeFn();
+        bar = 4;
+    } catch {
+        // Error handling
+    }
+    return bar;
+}   
+function unsafeFn() {
+    throw new Error();
+}
+```
+
 ## When Not To Use It
 
 If you don't want to be notified about values that are never read, you can safely disable this rule.

lib/rules/no-useless-assignment.js

@@ -151,6 +151,7 @@ module.exports = {
          * @property {Record<string, ScopeStackSegmentInfo>} segments The map of ScopeStackSegmentInfo.
          * @property {Set<CodePathSegment>} currentSegments The current CodePathSegments.
          * @property {Map<Variable, AssignmentInfo[]>} assignments The map of list of AssignmentInfo for each variable.
+         * @property {Array} tryStatementBlocks The array of TryStatement block nodes in this scope stack.
          */
         /**
          * @typedef {Object} ScopeStackSegmentInfo
@@ -229,6 +230,16 @@ module.exports = {
              */
             function verifyAssignmentIsUsed(targetAssignment, allAssignments) {
 
+                // Skip assignment if it is in a try block.
+                const isAssignmentInTryBlock = target.tryStatementBlocks.some(tryBlock =>
+                    tryBlock.range[0] <= targetAssignment.identifier.range[0] &&
+                    targetAssignment.identifier.range[1] <= tryBlock.range[1]
+                );
+
+                if (isAssignmentInTryBlock) {
+                    return;
+                }
+
                 /**
                  * @typedef {Object} SubsequentSegmentData
                  * @property {CodePathSegment} segment The code path segment
@@ -445,7 +456,8 @@ module.exports = {
                     scope,
                     segments: Object.create(null),
                     currentSegments: new Set(),
-                    assignments: new Map()
+                    assignments: new Map(),
+                    tryStatementBlocks: []
                 };
                 codePathStartScopes.add(scopeStack.scope);
             },
@@ -463,6 +475,9 @@ module.exports = {
             onCodePathSegmentEnd(segment) {
                 scopeStack.currentSegments.delete(segment);
             },
+            TryStatement(node) {
+                scopeStack.tryStatementBlocks.push(node.block);
+            },
             Identifier(node) {
                 for (const segment of scopeStack.currentSegments) {
                     const segmentInfo = scopeStack.segments[segment.id];

tests/lib/rules/no-useless-assignment.js

@@ -370,6 +370,49 @@ ruleTester.run("no-useless-assignment", rule, {
         console.log(a, b);`,
         `let { a, b: {c = a} = {} } = obj;
         console.log(c);`,
+
+        // ignore assignments in try block
+        `function foo(){
+            let bar;
+            try {
+                bar = 2;
+                unsafeFn();
+                return { error: undefined };
+            } catch {
+                return { bar }; 
+            }
+        }   
+        function unsafeFn() {
+            throw new Error();
+        }`,
+        `function foo(){
+            let bar, baz;
+            try {
+                bar = 2;
+                unsafeFn();
+                return { error: undefined };
+            } catch {
+               baz = bar;
+            }
+            return baz;
+        }   
+        function unsafeFn() {
+            throw new Error();
+        }`,
+        `function foo(){
+            let bar;
+            try {
+                bar = 2;
+                unsafeFn();
+                bar = 4;
+            } catch {
+               // handle error
+            }
+            return bar;
+        }   
+        function unsafeFn() {
+            throw new Error();
+        }`,
         {
             code: `/*eslint test/jsx:1*/
                 function App() {