fix(eslint-plugin): [no-deprecated] report on deprecated properties with function-like types (typescript-eslint#9977)

auvred · web-flow · commit 2a956b224513 · 2024-09-13T11:15:50.000+09:30
diff --git a/packages/eslint-plugin/src/rules/no-deprecated.ts b/packages/eslint-plugin/src/rules/no-deprecated.ts
@@ -172,15 +172,32 @@ export default createRule({
       const signature = checker.getResolvedSignature(
         tsNode as ts.CallLikeExpression,
       );
+      const symbol = services.getSymbolAtLocation(node);
       if (signature) {
         const signatureDeprecation = getJsDocDeprecation(signature);
         if (signatureDeprecation !== undefined) {
           return signatureDeprecation;
         }
+
+        // Properties with function-like types have "deprecated" jsdoc
+        // on their symbols, not on their signatures:
+        //
+        // interface Props {
+        //   /** @deprecated */
+        //   property: () => 'foo'
+        //   ^symbol^  ^signature^
+        // }
+        const symbolDeclarationKind = symbol?.declarations?.[0].kind;
+        if (
+          symbolDeclarationKind !== ts.SyntaxKind.MethodDeclaration &&
+          symbolDeclarationKind !== ts.SyntaxKind.FunctionDeclaration &&
+          symbolDeclarationKind !== ts.SyntaxKind.MethodSignature
+        ) {
+          return getJsDocDeprecation(symbol);
+        }
       }
 
       // Or it could be a ClassDeclaration or a variable set to a ClassExpression.
-      const symbol = services.getSymbolAtLocation(node);
       const symbolAtLocation =
         symbol && checker.getTypeOfSymbolAtLocation(symbol, tsNode).getSymbol();
 
diff --git a/packages/eslint-plugin/tests/rules/no-deprecated.test.ts b/packages/eslint-plugin/tests/rules/no-deprecated.test.ts
@@ -100,6 +100,32 @@ ruleTester.run('no-deprecated', rule, {
 
       a('b');
     `,
+    `
+      class A {
+        a(value: 'b'): void;
+        /** @deprecated */
+        a(value: 'c'): void;
+      }
+      declare const foo: A;
+      foo.a('b');
+    `,
+    `
+      type A = {
+        (value: 'b'): void;
+        /** @deprecated */
+        (value: 'c'): void;
+      };
+      declare const foo: A;
+      foo('b');
+    `,
+    `
+      declare const a: {
+        new (value: 'b'): void;
+        /** @deprecated */
+        new (value: 'c'): void;
+      };
+      new a('b');
+    `,
     `
       namespace assert {
         export function fail(message?: string | Error): never;
@@ -651,6 +677,26 @@ ruleTester.run('no-deprecated', rule, {
         },
       ],
     },
+    {
+      code: `
+        declare const A: {
+          /** @deprecated */
+          new (): string;
+        };
+        
+        new A();
+      `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 14,
+          line: 7,
+          endLine: 7,
+          data: { name: 'A' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
     {
       code: `
         /** @deprecated */
@@ -737,6 +783,99 @@ ruleTester.run('no-deprecated', rule, {
         },
       ],
     },
+    {
+      code: `
+        declare class A {
+          /** @deprecated */
+          b: () => string;
+        }
+
+        declare const a: A;
+
+        a.b;
+      `,
+      errors: [
+        {
+          column: 11,
+          endColumn: 12,
+          line: 9,
+          endLine: 9,
+          data: { name: 'b' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class A {
+          /** @deprecated */
+          b: () => string;
+        }
+
+        declare const a: A;
+
+        a.b();
+      `,
+      only: false,
+      errors: [
+        {
+          column: 11,
+          endColumn: 12,
+          line: 9,
+          endLine: 9,
+          data: { name: 'b' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
+    {
+      code: `
+        interface A {
+          /** @deprecated */
+          b: () => string;
+        }
+
+        declare const a: A;
+
+        a.b();
+      `,
+      only: false,
+      errors: [
+        {
+          column: 11,
+          endColumn: 12,
+          line: 9,
+          endLine: 9,
+          data: { name: 'b' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
+    {
+      code: `
+        class A {
+          /** @deprecated */
+          b(): string {
+            return '';
+          }
+        }
+        
+        declare const a: A;
+        
+        a.b();
+      `,
+      only: false,
+      errors: [
+        {
+          column: 11,
+          endColumn: 12,
+          line: 11,
+          endLine: 11,
+          data: { name: 'b' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
     {
       code: `
         declare class A {
@@ -1155,6 +1294,27 @@ ruleTester.run('no-deprecated', rule, {
         },
       ],
     },
+    {
+      code: `
+        type A = {
+          (value: 'b'): void;
+          /** @deprecated */
+          (value: 'c'): void;
+        };
+        declare const foo: A;
+        foo('c');
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 12,
+          line: 8,
+          endLine: 8,
+          data: { name: 'foo' },
+          messageId: 'deprecated',
+        },
+      ],
+    },
     {
       code: `
         function a(
diff --git a/packages/utils/tests/ts-eslint/ESLint.test.ts b/packages/utils/tests/ts-eslint/ESLint.test.ts
@@ -13,6 +13,7 @@ describe('ESLint', () => {
       expect(eslint).toBeInstanceOf(FlatESLint);
     });
     it('legacy', () => {
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
       const eslint = new ESLint.LegacyESLint({
         // accepts legacy configs
         baseConfig: {
