feat(eslint-plugin): split no-empty-object-type out from ban-types and no-empty-interfaces

packages/eslint-plugin/docs/rules/ban-types.mdx

@@ -36,9 +36,6 @@ const func: Function = () => 1;
 // use safer object types
 const lowerObj: Object = {};
 const capitalObj: Object = { a: 'string' };
-
-const curly1: {} = 1;
-const curly2: {} = { a: 'string' };
 ```
 
 </TabItem>
@@ -58,9 +55,6 @@ const func: () => number = () => 1;
 // use safer object types
 const lowerObj: object = {};
 const capitalObj: { a: string } = { a: 'string' };
-
-const curly1: number = 1;
-const curly2: Record<'a', string> = { a: 'string' };
 ```
 
 </TabItem>
@@ -74,9 +68,6 @@ The default options provide a set of "best practices", intended to provide safet
 - Avoid the `Function` type, as it provides little safety for the following reasons:
   - It provides no type safety when calling the value, which means it's easy to provide the wrong arguments.
   - It accepts class declarations, which will fail when called, as they are called without the `new` keyword.
-- Avoid the `Object` and `{}` types, as they mean "any non-nullish value".
-  - This is a point of confusion for many developers, who think it means "any object type".
-  - See [this comment for more information](https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492).
 
 <details>
 <summary>Default Options</summary>

packages/eslint-plugin/docs/rules/no-empty-interface.mdx

@@ -61,3 +61,7 @@ interface Baz extends Foo, Bar {}
 ## When Not To Use It
 
 If you don't care about having empty/meaningless interfaces, then you will not need this rule.
+
+## Related To
+
+- [`no-empty-object-type`](./no-empty-object-type.mdx)

packages/eslint-plugin/docs/rules/no-empty-object-type.mdx

@@ -0,0 +1,65 @@
+---
+description: 'Disallow accidentally using the "empty object" type.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-empty-object-type** for documentation.
+
+The `{}`, or "empty object" type in TypeScript is a common source of confusion for developers unfamiliar with TypeScript's structural typing.
+`{}` represents any _non-nullish value_, including literals like `0` and `""`:
+
+```ts
+let anyNonNullishValue: {} = 'Intentionally allowed by TypeScript.';
+```
+
+Often, developers writing `{}` actually mean either:
+
+- `object`: representing any _object_ value
+- `unknown`: representing any value _other than `null` and `undefined`_
+
+To avoid confusion around the `{}` type allowing non-object values, this rule bans usage of the `{}` type.
+
+:::tip
+If you do have a use case for an API allowing any _non-nullish value_, you can always use an [ESLint disable comment](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) or [disable the rule in your ESLint config](https://eslint.org/docs/latest/use/configure/rules#using-configuration-files-1).
+:::
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+let anyObject: {};
+let anyValue: {};
+let emptyObject: {};
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+let anyObject: object;
+let anyValue: unknown;
+let emptyObject: Record<string, never>;
+```
+
+</TabItem>
+</Tabs>
+
+## When Not To Use It
+
+If your code commonly needs to represent the _"any non-nullish value"_ type, this rule may not be for you.
+Projects that extensively use type operations such as conditional types and mapped types oftentimes benefit from disabling this rule.
+
+## Further Reading
+
+- [Enhancement: [ban-types] Split the {} ban into a separate, better-phrased rule](https://github.com/typescript-eslint/typescript-eslint/issues/8700)
+- [The Empty Object Type in TypeScript](https://www.totaltypescript.com/the-empty-object-type-in-typescript)
+
+## Related To
+
+- [`no-empty-interface`](./no-empty-interface.mdx)

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

@@ -55,6 +55,7 @@ export = {
     'no-empty-function': 'off',
     '@typescript-eslint/no-empty-function': 'error',
     '@typescript-eslint/no-empty-interface': 'error',
+    '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-extraneous-class': 'error',

packages/eslint-plugin/src/configs/recommended-type-checked.ts

@@ -18,6 +18,7 @@ export = {
     '@typescript-eslint/no-base-to-string': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-duplicate-type-constituents': 'error',
+    '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-floating-promises': 'error',

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

@@ -15,6 +15,7 @@ export = {
     'no-array-constructor': 'off',
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
+    '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-misused-new': 'error',

packages/eslint-plugin/src/configs/strict-type-checked.ts

@@ -24,6 +24,7 @@ export = {
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-duplicate-type-constituents': 'error',
     '@typescript-eslint/no-dynamic-delete': 'error',
+    '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-extraneous-class': 'error',

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

@@ -19,6 +19,7 @@ export = {
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-dynamic-delete': 'error',
+    '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-extraneous-class': 'error',

packages/eslint-plugin/src/rules/ban-types.ts

@@ -73,7 +73,10 @@ const defaultTypes: Types = {
     message: 'Use bigint instead',
     fixWith: 'bigint',
   },
-
+  Object: {
+    message: 'Use object instead',
+    fixWith: 'object',
+  },
   Function: {
     message: [
       'The `Function` type accepts any function-like value.',
@@ -82,32 +85,6 @@ const defaultTypes: Types = {
       'If you are expecting the function to accept certain arguments, you should explicitly define the function shape.',
     ].join('\n'),
   },
-
-  // object typing
-  Object: {
-    message: [
-      'The `Object` type actually means "any non-nullish value", so it is marginally better than `unknown`.',
-      '- If you want a type meaning "any object", you probably want `object` instead.',
-      '- If you want a type meaning "any value", you probably want `unknown` instead.',
-      '- If you really want a type meaning "any non-nullish value", you probably want `NonNullable<unknown>` instead.',
-    ].join('\n'),
-    suggest: ['object', 'unknown', 'NonNullable<unknown>'],
-  },
-  '{}': {
-    message: [
-      '`{}` actually means "any non-nullish value".',
-      '- If you want a type meaning "any object", you probably want `object` instead.',
-      '- If you want a type meaning "any value", you probably want `unknown` instead.',
-      '- If you want a type meaning "empty object", you probably want `Record<string, never>` instead.',
-      '- If you really want a type meaning "any non-nullish value", you probably want `NonNullable<unknown>` instead.',
-    ].join('\n'),
-    suggest: [
-      'object',
-      'unknown',
-      'Record<string, never>',
-      'NonNullable<unknown>',
-    ],
-  },
 };
 
 export const TYPE_KEYWORDS = {

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

@@ -36,6 +36,7 @@ import noDuplicateTypeConstituents from './no-duplicate-type-constituents';
 import noDynamicDelete from './no-dynamic-delete';
 import noEmptyFunction from './no-empty-function';
 import noEmptyInterface from './no-empty-interface';
+import noEmptyObjectType from './no-empty-object-type';
 import noExplicitAny from './no-explicit-any';
 import noExtraNonNullAssertion from './no-extra-non-null-assertion';
 import noExtraneousClass from './no-extraneous-class';
@@ -160,6 +161,7 @@ export default {
   'no-dynamic-delete': noDynamicDelete,
   'no-empty-function': noEmptyFunction,
   'no-empty-interface': noEmptyInterface,
+  'no-empty-object-type': noEmptyObjectType,
   'no-explicit-any': noExplicitAny,
   'no-extra-non-null-assertion': noExtraNonNullAssertion,
   'no-extraneous-class': noExtraneousClass,

packages/eslint-plugin/src/rules/no-empty-object-type.ts

@@ -0,0 +1,45 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+
+import { createRule } from '../util';
+
+export default createRule({
+  name: 'no-empty-object-type',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow accidentally using the "empty object" type',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      banEmptyObjectType: [
+        'The `{}` ("empty object") type allows any non-nullish value, including literals like `0` and `""`.',
+        "- If that's what you want, disable this lint rule with an inline comment or in your ESLint config.",
+        '- If you want a type meaning "any object", you probably want `object` instead.',
+        '- If you want a type meaning "any value", you probably want `unknown` instead.',
+        '- If you want a type meaning "empty object", you probably want `Record<string, never>` instead.',
+      ].join('\n'),
+      replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      'TSTypeLiteral[members.length=0]'(node): void {
+        context.report({
+          messageId: 'banEmptyObjectType',
+          node,
+          suggest: ['object', 'unknown', 'Record<string, never>'].map(
+            replacement => ({
+              data: { replacement },
+              messageId: 'replaceEmptyObjectType',
+              fix: (fixer): TSESLint.RuleFix =>
+                fixer.replaceText(node, replacement),
+            }),
+          ),
+        });
+      },
+    };
+  },
+});

packages/eslint-plugin/tests/rules/ban-types.test.ts

@@ -137,44 +137,6 @@ ruleTester.run('ban-types', rule, {
       ],
       options,
     },
-    {
-      code: 'let a: Object;',
-      output: null,
-      errors: [
-        {
-          messageId: 'bannedTypeMessage',
-          data: {
-            name: 'Object',
-            customMessage: [
-              ' The `Object` type actually means "any non-nullish value", so it is marginally better than `unknown`.',
-              '- If you want a type meaning "any object", you probably want `object` instead.',
-              '- If you want a type meaning "any value", you probably want `unknown` instead.',
-              '- If you really want a type meaning "any non-nullish value", you probably want `NonNullable<unknown>` instead.',
-            ].join('\n'),
-          },
-          line: 1,
-          column: 8,
-          suggestions: [
-            {
-              messageId: 'bannedTypeReplacement',
-              data: { name: 'Object', replacement: 'object' },
-              output: 'let a: object;',
-            },
-            {
-              messageId: 'bannedTypeReplacement',
-              data: { name: 'Object', replacement: 'unknown' },
-              output: 'let a: unknown;',
-            },
-            {
-              messageId: 'bannedTypeReplacement',
-              data: { name: 'Object', replacement: 'NonNullable<unknown>' },
-              output: 'let a: NonNullable<unknown>;',
-            },
-          ],
-        },
-      ],
-      options: [{}],
-    },
     {
       code: 'let aa: Foo;',
       output: null,