feat: add no-unsafe-unary-minus rule

packages/eslint-plugin/docs/rules/no-unsafe-unary-minus.md

@@ -0,0 +1,37 @@
+---
+description: 'Require unary negation to take a number.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unsafe-unary-minus** for documentation.
+
+TypeScript does not prevent you from putting a minus sign before things other than numbers:
+
+```ts
+const s = 'hello';
+const x = -s; // x is NaN
+```
+
+This rule restricts the unary `-` operator to `number | bigint`.
+
+## Examples
+
+### ❌ Incorrect
+
+```ts
+const f = (a: string) => -a;
+const g = (a: {}) => -a;
+```
+
+### ✅ Correct
+
+```ts
+const a = -42;
+const b = -42n;
+const f1 = (a: number) => -a;
+const f2 = (a: bigint) => -a;
+const f3 = (a: number | bigint) => -a;
+const f4 = (a: any) => -a;
+const f5 = (a: 1 | 2) => -a;
+```

packages/eslint-plugin/src/configs/all.ts

@@ -123,6 +123,7 @@ export = {
     '@typescript-eslint/no-unsafe-enum-comparison': 'error',
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
+    '@typescript-eslint/no-unsafe-unary-minus': 'error',
     'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
     'no-unused-vars': 'off',

packages/eslint-plugin/src/rules/index.ts

@@ -86,6 +86,7 @@ import noUnsafeDeclarationMerging from './no-unsafe-declaration-merging';
 import noUnsafeEnumComparison from './no-unsafe-enum-comparison';
 import noUnsafeMemberAccess from './no-unsafe-member-access';
 import noUnsafeReturn from './no-unsafe-return';
+import noUnsafeUnaryMinus from './no-unsafe-unary-minus';
 import noUnusedExpressions from './no-unused-expressions';
 import noUnusedVars from './no-unused-vars';
 import noUseBeforeDefine from './no-use-before-define';
@@ -221,6 +222,7 @@ export default {
   'no-unsafe-enum-comparison': noUnsafeEnumComparison,
   'no-unsafe-member-access': noUnsafeMemberAccess,
   'no-unsafe-return': noUnsafeReturn,
+  'no-unsafe-unary-minus': noUnsafeUnaryMinus,
   'no-unused-expressions': noUnusedExpressions,
   'no-unused-vars': noUnusedVars,
   'no-use-before-define': noUseBeforeDefine,

packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts

@@ -0,0 +1,55 @@
+import type * as ts from 'typescript';
+
+import * as util from '../util';
+
+interface TypeChecker extends ts.TypeChecker {
+  // https://github.com/microsoft/TypeScript/issues/9879
+  isTypeAssignableTo(source: ts.Type, target: ts.Type): boolean;
+  getUnionType(types: ts.Type[]): ts.Type;
+}
+
+type Options = [];
+type MessageIds = 'unaryMinus';
+
+export default util.createRule<Options, MessageIds>({
+  name: 'no-unsafe-unary-minus',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require unary negation to take a number',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unaryMinus: 'Invalid type "{{type}}" of template literal expression.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      UnaryExpression(node): void {
+        if (node.operator !== '-') {
+          return;
+        }
+        const services = util.getParserServices(context);
+        const argType = services.getTypeAtLocation(node.argument);
+        const checker = services.program.getTypeChecker() as TypeChecker;
+        if (
+          !checker.isTypeAssignableTo(
+            argType,
+            checker.getUnionType([
+              checker.getNumberType(), // first exposed in TypeScript v5.1
+              checker.getBigIntType(), // first added in TypeScript v5.1
+            ]),
+          )
+        ) {
+          context.report({
+            messageId: 'unaryMinus',
+            node,
+            data: { type: checker.typeToString(argType) },
+          });
+        }
+      },
+    };
+  },
+});

packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts

@@ -0,0 +1,31 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
+import rule from '../../src/rules/no-unsafe-unary-minus';
+import { getFixturesRootDir } from '../RuleTester';
+
+const rootDir = getFixturesRootDir();
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2015,
+    tsconfigRootDir: rootDir,
+    project: './tsconfig.json',
+  },
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('no-unsafe-unary-minus', rule, {
+  valid: [
+    '+42;',
+    '-42;',
+    '-42n;',
+    '(a: number) => -a;',
+    '(a: bigint) => -a;',
+    '(a: number | bigint) => -a;',
+    '(a: any) => -a;',
+    '(a: 1 | 2) => -a;',
+  ],
+  invalid: [
+    { code: '(a: string) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: {}) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+  ],
+});