Skip void (p.catch(...)) in parentheses, and report declarations after the assignment

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TrbmayRraf25aTwCCj1iv2

Author: claude

rules.ts

@@ -387,6 +387,13 @@ function skipParentheses(expr: ts.Expression): ts.Expression {
   return current;
 }
 
+/** The nearest ancestor that is not a parenthesized expression. */
+function skipParenthesesUp(node: ts.Node): ts.Node {
+  let current = node.parent;
+  while (ts.isParenthesizedExpression(current)) current = current.parent;
+  return current;
+}
+
 /** The cast directly inside this one, looking through parentheses: `(x as A) as B`. */
 function innerCast(node: AssertionNode): AssertionNode | undefined {
   const inner = skipParentheses(node.expression);
@@ -1046,8 +1053,11 @@ function isFallbackCatch(clause: ts.CatchClause): boolean {
  * a return after the try.
  */
 function assignsOnlyOuterVariables(tryStatement: ts.TryStatement): boolean {
-  // Local declarations feed the assignment: `const stats = await stat(p); isDir = stats.isDirectory();`
-  const statements = tryStatement.tryBlock.statements.filter(statement => !ts.isVariableStatement(statement));
+  // Local declarations first feed the assignment: `const stats = await stat(p); isDir = stats.isDirectory();`.
+  // One after it is work whose failure the catch would hide.
+  const all = tryStatement.tryBlock.statements;
+  const firstAssignment = all.findIndex(statement => !ts.isVariableStatement(statement));
+  const statements = firstAssignment === -1 ? [] : all.slice(firstAssignment);
   if (statements.length === 0) return false;
   const scope = enclosingFunctionOrFile(tryStatement);
   return statements.every(statement => {
@@ -1248,7 +1258,7 @@ export function analyzeSource(sourceText: string, fileName: string): Finding[] {
       const handler = node.arguments[0];
       // `void p.catch(() => {})` says the result is dropped on purpose.
       if ((ts.isArrowFunction(handler) || ts.isFunctionExpression(handler)) && ts.isBlock(handler.body) &&
-        handler.body.statements.length === 0 && !ts.isVoidExpression(node.parent) &&
+        handler.body.statements.length === 0 && !ts.isVoidExpression(skipParenthesesUp(node)) &&
         commentsWithin(handler.body).length === 0 && !isIgnoredBinding(handler.parameters[0]?.name)) {
         report('empty_catch', node.expression.name);
       }

tests/rules.test.ts

@@ -196,6 +196,7 @@ test('empty catch with an underscore binding is deliberate', () => {
   assert.equal(countOf('p.catch((_err) => {});', 'empty_catch'), 0);
   assert.equal(countOf('p.catch((err) => {});', 'empty_catch'), 1);
   assert.equal(countOf('void reader.cancel().catch(() => {});', 'empty_catch'), 0);
+  assert.equal(countOf('void (reader.cancel().catch(() => {}));', 'empty_catch'), 0);
   assert.equal(countOf('try { a(); } catch (err) {}', 'empty_catch'), 1);
 });
 
@@ -233,7 +234,9 @@ test('empty catch: a variable assigned in the try keeps its earlier value as the
     'function f(src: S) {\n  let x = 1;\n  try {\n    x = load();\n  } catch {}\n  ({ x } = src);\n  [x] = [2];\n}',
     'function f(xs: number[]) {\n  let x = 1;\n  try {\n    x = load();\n  } catch {}\n  return xs.map((x) => x * 2);\n}',
     'function f(xs: number[]) {\n  let x = 1;\n  try {\n    x = load();\n  } catch {}\n  for (const x of xs) use(x);\n  if (xs.length) { const x = 2; use(x); }\n  xs.forEach(() => { var x = 3; use(x); });\n}',
-    'function f() {\n  try {\n    const x = load();\n  } catch {}\n}'
+    'function f() {\n  try {\n    const x = load();\n  } catch {}\n}',
+    // A declaration after the assignment is more work the catch would hide.
+    'function f() {\n  let x = 1;\n  try {\n    x = load();\n    const y = save(x);\n  } catch {}\n  return x;\n}'
   ]) {
     assert.equal(countOf(code, 'empty_catch'), 1, code);
   }