JS-1381 Fix S6598 false positive for interfaces used as defineEmits type argument in Vue (#6525)

Co-authored-by: Vibe Bot <vibe-bot@sonarsource.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Co-authored-by: Francois Mora <francois.mora@sonarsource.com>

Author: 4 people

packages/jsts/src/rules/S6598/decorator.ts

@@ -17,11 +17,79 @@
 // https://sonarsource.github.io/rspec/#/rspec/S6598/javascript
 
 import type { Rule } from 'eslint';
+import type estree from 'estree';
+import type { TSESTree } from '@typescript-eslint/utils';
 import { generateMeta } from '../helpers/generate-meta.js';
 import { interceptReport } from '../helpers/decorators/interceptor.js';
+import { isInsideVueSetupScript } from '../helpers/vue.js';
 import * as meta from './generated-meta.js';
 
+function getTopLevelCallExprs(context: Rule.RuleContext): TSESTree.CallExpression[] {
+  return context.sourceCode.ast.body.flatMap(stmt => {
+    if (stmt.type === 'ExpressionStatement' && stmt.expression.type === 'CallExpression') {
+      return [stmt.expression as unknown as TSESTree.CallExpression];
+    }
+    if (stmt.type === 'VariableDeclaration') {
+      return stmt.declarations
+        .filter(decl => decl.init?.type === 'CallExpression')
+        .map(decl => decl.init as unknown as TSESTree.CallExpression);
+    }
+    return [];
+  });
+}
+
+function isReferencedByDefineEmits(name: string, context: Rule.RuleContext): boolean {
+  return getTopLevelCallExprs(context).some(call => {
+    if (call.callee.type !== 'Identifier' || call.callee.name !== 'defineEmits') {
+      return false;
+    }
+    return (
+      call.typeArguments?.params?.some(
+        p =>
+          p.type === 'TSTypeReference' &&
+          p.typeName.type === 'Identifier' &&
+          p.typeName.name === name,
+      ) ?? false
+    );
+  });
+}
+
+function isDefineEmitsTypeArg(
+  node: TSESTree.TSCallSignatureDeclaration,
+  context: Rule.RuleContext,
+): boolean {
+  const { parent } = node;
+  if (parent.type === 'TSTypeLiteral') {
+    const grandParent = parent.parent;
+    // Inline type literal used directly as a defineEmits type argument, e.g.:
+    //   defineEmits<{ ...function signature... }>()
+    if (grandParent.type === 'TSTypeParameterInstantiation') {
+      const greatGrandParent = grandParent.parent;
+      if (greatGrandParent.type === 'CallExpression') {
+        const { callee } = greatGrandParent;
+        return callee.type === 'Identifier' && callee.name === 'defineEmits';
+      }
+      return false;
+    }
+    // Type alias whose body contains the call signature, referenced by defineEmits, e.g.:
+    //   type Emits = { ...function signature... }
+    //   defineEmits<Emits>()
+    if (grandParent.type === 'TSTypeAliasDeclaration') {
+      return isReferencedByDefineEmits(grandParent.id.name, context);
+    }
+    return false;
+  }
+  // Interface whose body contains the call signature, referenced by defineEmits, e.g.:
+  //   interface Emits { ...function signature... }
+  //   defineEmits<Emits>()
+  if (parent.type === 'TSInterfaceBody') {
+    return isReferencedByDefineEmits(parent.parent.id.name, context);
+  }
+  return false;
+}
+
 // Rewording one of the issue messages reported by the core implementation.
+// Suppresses false positives for defineEmits type arguments in Vue <script setup>.
 export function decorate(rule: Rule.RuleModule): Rule.RuleModule {
   return interceptReport(
     {
@@ -37,9 +105,18 @@ export function decorate(rule: Rule.RuleModule): Rule.RuleModule {
       }),
     },
     (context, reportDescriptor) => {
-      context.report({
-        ...reportDescriptor,
-      });
+      const node = (reportDescriptor as unknown as { node: TSESTree.Node }).node;
+      if (node.type !== 'TSCallSignatureDeclaration') {
+        context.report({ ...reportDescriptor });
+        return;
+      }
+      if (!isInsideVueSetupScript(node as unknown as estree.Node, context)) {
+        context.report({ ...reportDescriptor });
+        return;
+      }
+      if (!isDefineEmitsTypeArg(node, context)) {
+        context.report({ ...reportDescriptor });
+      }
     },
   );
 }

packages/jsts/src/rules/S6598/unit.test.ts

@@ -15,12 +15,19 @@
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 import { rule } from './index.js';
+import { rules as tsEslintRules } from '../external/typescript-eslint/index.js';
 import { NoTypeCheckingRuleTester } from '../../../tests/tools/testers/rule-tester.js';
 import { describe, it } from 'node:test';
+import vueParser from 'vue-eslint-parser';
+import tsParser from '@typescript-eslint/parser';
 
 describe('S6598', () => {
   it('S6598', () => {
     const ruleTester = new NoTypeCheckingRuleTester();
+    const vueRuleTester = new NoTypeCheckingRuleTester({
+      parser: vueParser,
+      parserOptions: { parser: tsParser },
+    });
 
     ruleTester.run(`Decorated rule should reword the issue message`, rule, {
       valid: [
@@ -41,5 +48,79 @@ describe('S6598', () => {
         },
       ],
     });
+
+    vueRuleTester.run('defineEmits type argument in Vue script setup', rule, {
+      valid: [
+        {
+          // Compliant: named interface as defineEmits type arg
+          code: `<script setup lang="ts">
+interface ClickEmits {
+  (e: 'click'): void;
+}
+const emit = defineEmits<ClickEmits>();
+</script>`,
+        },
+        {
+          // Compliant: inline type literal as defineEmits type arg
+          code: `<script setup lang="ts">
+const emit = defineEmits<{
+  (e: 'submit'): void;
+}>();
+</script>`,
+        },
+        {
+          // Compliant: named type alias as defineEmits type arg
+          code: `<script setup lang="ts">
+type ChangeEmits = {
+  (e: 'change', value: string): void;
+};
+const emit = defineEmits<ChangeEmits>();
+</script>`,
+        },
+      ],
+      invalid: [
+        {
+          // Interface unrelated to defineEmits is still flagged
+          code: `<script setup lang="ts">
+interface MyTransformer {
+  (input: string): number;
+}
+</script>`,
+          errors: 1,
+          output: `<script setup lang="ts">
+type MyTransformer = (input: string) => number;
+</script>`,
+        },
+      ],
+    });
+
+    // Sentinel: verify the upstream rule still raises an issue on the defineEmits FP pattern.
+    // If this test fails, upstream prefer-function-type no longer flags this pattern natively,
+    // and the suppression logic in decorator.ts can be safely removed.
+    new NoTypeCheckingRuleTester({
+      parser: vueParser,
+      parserOptions: { parser: tsParser },
+    }).run(
+      'upstream prefer-function-type raises issue on defineEmits type arg (sentinel)',
+      tsEslintRules['prefer-function-type'],
+      {
+        valid: [],
+        invalid: [
+          {
+            code: `<script setup lang="ts">
+interface ClickEmits {
+  (e: 'click'): void;
+}
+const emit = defineEmits<ClickEmits>();
+</script>`,
+            errors: 1,
+            output: `<script setup lang="ts">
+type ClickEmits = (e: 'click') => void;
+const emit = defineEmits<ClickEmits>();
+</script>`,
+          },
+        ],
+      },
+    );
   });
 });