typescript-eslint · y-hsgw · Jan 17, 2025 · Jan 17, 2025 · Jan 17, 2025 · Jan 25, 2025
diff --git a/packages/eslint-plugin/src/rules/no-deprecated.ts b/packages/eslint-plugin/src/rules/no-deprecated.ts
@@ -12,6 +12,7 @@ import {
  nullThrows,
  typeOrValueSpecifiersSchema,
  typeMatchesSomeSpecifier,
+  valueMatchesSomeSpecifier,
 } from '../util';

 type IdentifierLike =
@@ -375,7 +376,10 @@ export default createRule<Options, MessageIds>({
      }

      const type = services.getTypeAtLocation(node);
-      if (typeMatchesSomeSpecifier(type, allow, services.program)) {
+      if (
+        typeMatchesSomeSpecifier(type, allow, services.program) ||
+        valueMatchesSomeSpecifier(node, allow, services.program, type)
+      ) {
        return;
      }


diff --git a/packages/eslint-plugin/tests/rules/no-deprecated.test.ts b/packages/eslint-plugin/tests/rules/no-deprecated.test.ts
@@ -332,6 +332,21 @@ ruleTester.run('no-deprecated', rule, {
    {
      code: `
 /** @deprecated */
+function A() {
+  return <div />;
+}
+
+const a = <A></A>;
+      `,
+      options: [
+        {
+          allow: [{ from: 'file', name: 'A' }],
+        },
+      ],
+    },
+    {
+      code: `
+/** @deprecated */
 declare class A {}

 new A();
@@ -344,7 +359,62 @@ new A();
    },
    {
      code: `
+/** @deprecated */
+const deprecatedValue = 45;
+const bar = deprecatedValue;
+      `,
+      options: [
+        {
+          allow: [{ from: 'file', name: 'deprecatedValue' }],
+        },
+      ],
+    },
+    {
+      code: `
+class MyClass {
+  /** @deprecated */
+  #privateProp = 42;
+  value = this.#privateProp;
+}
+      `,
+      options: [
+        {
+          allow: [{ from: 'file', name: 'privateProp' }],
+        },
+      ],
+    },
+    {
+      code: `
+/** @deprecated */
+const deprecatedValue = 45;
+const bar = deprecatedValue;
+      `,
+      options: [
+        {
+          allow: ['deprecatedValue'],
+        },
+      ],
+    },
+    {
+      code: `
 import { exists } from 'fs';
+exists('/foo');
+      `,
+      options: [
+        {
+          allow: [
+            {
+              from: 'package',
+              name: 'exists',
+              package: 'fs',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+const { exists } = import('fs');
 exists('/foo');
      `,
      options: [
@@ -2915,6 +2985,37 @@ class B extends A {
        },
      ],
    },
+    {
+      code: `
+import { exists } from 'fs';
+exists('/foo');
+      `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            name: 'exists',
+            reason:
+              'Since v1.0.0 - Use {@link stat} or {@link access} instead.',
+          },
+          endColumn: 7,
+          endLine: 3,
+          line: 3,
+          messageId: 'deprecatedWithReason',
+        },
+      ],
+      options: [
+        {
+          allow: [
+            {
+              from: 'package',
+              name: 'exists',
+              package: 'hoge',
+            },
+          ],
+        },
+      ],
+    },
    {
      code: `
        declare class A {

diff --git a/packages/type-utils/src/TypeOrValueSpecifier.ts b/packages/type-utils/src/TypeOrValueSpecifier.ts
@@ -1,6 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/types';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
 import type * as ts from 'typescript';

+import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import * as tsutils from 'ts-api-utils';

 import { specifierNameMatches } from './typeOrValueSpecifiers/specifierNameMatches';
@@ -219,3 +221,69 @@ export const typeMatchesSomeSpecifier = (
  program: ts.Program,
 ): boolean =>
  specifiers.some(specifier => typeMatchesSpecifier(type, specifier, program));
+
+const getSpecifierNames = (specifierName: string | string[]): string[] => {
+  return typeof specifierName === 'string' ? [specifierName] : specifierName;
+};
+
+const getStaticName = (node: TSESTree.Node): string | undefined => {
+  if (
+    node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.JSXIdentifier ||
+    node.type === AST_NODE_TYPES.PrivateIdentifier
+  ) {
+    return node.name;
+  }
+
+  if (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+    return node.value;
+  }
+
+  return undefined;
+};
+
+export function valueMatchesSpecifier(
+  node: TSESTree.Node,
+  specifier: TypeOrValueSpecifier,
+  program: ts.Program,
+  type: ts.Type,
+): boolean {
+  const staticName = getStaticName(node);
+  if (!staticName) {
+    return false;
+  }
+
+  if (typeof specifier === 'string') {
+    return specifier === staticName;
+  }
+
+  if (!getSpecifierNames(specifier.name).includes(staticName)) {
+    return false;
+  }
+
+  if (specifier.from === 'package') {
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const declarations = symbol?.getDeclarations() ?? [];
+    const declarationFiles = declarations.map(declaration =>
+      declaration.getSourceFile(),
+    );
+    return typeDeclaredInPackageDeclarationFile(
+      specifier.package,
+      declarations,
+      declarationFiles,
+      program,
+    );
+  }
+
+  return true;
+}
+
+export const valueMatchesSomeSpecifier = (
+  node: TSESTree.Node,
+  specifiers: TypeOrValueSpecifier[] = [],
+  program: ts.Program,
+  type: ts.Type,
+): boolean =>
+  specifiers.some(specifier =>
+    valueMatchesSpecifier(node, specifier, program, type),
+  );