feat(eslint-plugin): add object-curly-spacing rule

packages/eslint-plugin/README.md

@@ -218,6 +218,7 @@ In these cases, we create what we call an extension rule; a rule within our plug
 | [`@typescript-eslint/no-unused-vars`](./docs/rules/no-unused-vars.md)                           | Disallow unused variables                                                            | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/no-use-before-define`](./docs/rules/no-use-before-define.md)               | Disallow the use of variables before they are defined                                |                    |          |                   |
 | [`@typescript-eslint/no-useless-constructor`](./docs/rules/no-useless-constructor.md)           | Disallow unnecessary constructors                                                    |                    |          |                   |
+| [`@typescript-eslint/object-curly-spacing`](./docs/rules/object-curly-spacing.md)               | Enforce consistent spacing inside braces                                             |                    | :wrench: |                   |
 | [`@typescript-eslint/quotes`](./docs/rules/quotes.md)                                           | Enforce the consistent use of either backticks, double, or single quotes             |                    | :wrench: |                   |
 | [`@typescript-eslint/require-await`](./docs/rules/require-await.md)                             | Disallow async functions which have no `await` expression                            | :heavy_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/return-await`](./docs/rules/return-await.md)                               | Enforces consistent returning of awaited values                                      |                    | :wrench: | :thought_balloon: |

packages/eslint-plugin/docs/rules/object-curly-spacing.md

@@ -0,0 +1,22 @@
+# Enforce consistent spacing inside braces (`object-curly-spacing`)
+
+## Rule Details
+
+This rule extends the base [`eslint/object-curly-spacing`](https://eslint.org/docs/rules/object-curly-spacing) rule.
+It adds support for TypeScript's object types.
+
+## How to use
+
+```cjson
+{
+  // note you must disable the base rule as it can report incorrect errors
+  "object-curly-spacing": "off",
+  "@typescript-eslint/object-curly-spacing": ["error"]
+}
+```
+
+## Options
+
+See [`eslint/object-curly-spacing` options](https://eslint.org/docs/rules/object-curly-spacing#options).
+
+<sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/object-curly-spacing.md)</sup>

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

@@ -113,6 +113,8 @@ export = {
     '@typescript-eslint/no-useless-constructor': 'error',
     '@typescript-eslint/no-var-requires': 'error',
     '@typescript-eslint/non-nullable-type-assertion-style': 'error',
+    'object-curly-spacing': 'off',
+    '@typescript-eslint/object-curly-spacing': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
     '@typescript-eslint/prefer-enum-initializers': 'error',
     '@typescript-eslint/prefer-for-of': 'error',

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

@@ -79,6 +79,7 @@ import noUseBeforeDefine from './no-use-before-define';
 import noUselessConstructor from './no-useless-constructor';
 import noVarRequires from './no-var-requires';
 import nonNullableTypeAssertionStyle from './non-nullable-type-assertion-style';
+import objectCurlySpacing from './object-curly-spacing';
 import preferAsConst from './prefer-as-const';
 import preferEnumInitializers from './prefer-enum-initializers';
 import preferForOf from './prefer-for-of';
@@ -195,6 +196,7 @@ export default {
   'no-useless-constructor': noUselessConstructor,
   'no-var-requires': noVarRequires,
   'non-nullable-type-assertion-style': nonNullableTypeAssertionStyle,
+  'object-curly-spacing': objectCurlySpacing,
   'prefer-as-const': preferAsConst,
   'prefer-enum-initializers': preferEnumInitializers,
   'prefer-for-of': preferForOf,

packages/eslint-plugin/src/rules/object-curly-spacing.ts

@@ -0,0 +1,267 @@
+import {
+  AST_NODE_TYPES,
+  AST_TOKEN_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import baseRule from 'eslint/lib/rules/object-curly-spacing';
+import {
+  createRule,
+  InferMessageIdsTypeFromRule,
+  InferOptionsTypeFromRule,
+  isClosingBraceToken,
+  isClosingBracketToken,
+  isTokenOnSameLine,
+} from '../util';
+
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+
+export default createRule<Options, MessageIds>({
+  name: 'object-curly-spacing',
+  meta: {
+    ...baseRule.meta,
+    docs: {
+      description: 'Enforce consistent spacing inside braces',
+      category: 'Stylistic Issues',
+      recommended: false,
+      extendsBaseRule: true,
+    },
+  },
+  defaultOptions: ['never'],
+  create(context) {
+    const spaced = context.options[0] === 'always';
+    const sourceCode = context.getSourceCode();
+
+    /**
+     * Determines whether an option is set, relative to the spacing option.
+     * If spaced is "always", then check whether option is set to false.
+     * If spaced is "never", then check whether option is set to true.
+     * @param option The option to exclude.
+     * @returns Whether or not the property is excluded.
+     */
+    function isOptionSet(
+      option: 'arraysInObjects' | 'objectsInObjects',
+    ): boolean {
+      return context.options[1]
+        ? context.options[1][option] === !spaced
+        : false;
+    }
+
+    const options = {
+      spaced,
+      arraysInObjectsException: isOptionSet('arraysInObjects'),
+      objectsInObjectsException: isOptionSet('objectsInObjects'),
+    };
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param node The node to report in the event of an error.
+     * @param token The token to use for the report.
+     */
+    function reportNoBeginningSpace(
+      node: TSESTree.TSTypeLiteral,
+      token: TSESTree.Token,
+    ): void {
+      const nextToken = context
+        .getSourceCode()
+        .getTokenAfter(token, { includeComments: true })!;
+
+      context.report({
+        node,
+        loc: { start: token.loc.end, end: nextToken.loc.start },
+        messageId: 'unexpectedSpaceAfter',
+        data: {
+          token: token.value,
+        },
+        fix(fixer) {
+          return fixer.removeRange([token.range[1], nextToken.range[0]]);
+        },
+      });
+    }
+
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param node The node to report in the event of an error.
+     * @param token The token to use for the report.
+     */
+    function reportNoEndingSpace(
+      node: TSESTree.TSTypeLiteral,
+      token: TSESTree.Token,
+    ): void {
+      const previousToken = context
+        .getSourceCode()
+        .getTokenBefore(token, { includeComments: true })!;
+
+      context.report({
+        node,
+        loc: { start: previousToken.loc.end, end: token.loc.start },
+        messageId: 'unexpectedSpaceBefore',
+        data: {
+          token: token.value,
+        },
+        fix(fixer) {
+          return fixer.removeRange([previousToken.range[1], token.range[0]]);
+        },
+      });
+    }
+
+    /**
+     * Reports that there should be a space after the first token
+     * @param node The node to report in the event of an error.
+     * @param token The token to use for the report.
+     */
+    function reportRequiredBeginningSpace(
+      node: TSESTree.TSTypeLiteral,
+      token: TSESTree.Token,
+    ): void {
+      context.report({
+        node,
+        loc: token.loc,
+        messageId: 'requireSpaceAfter',
+        data: {
+          token: token.value,
+        },
+        fix(fixer) {
+          return fixer.insertTextAfter(token, ' ');
+        },
+      });
+    }
+
+    /**
+     * Reports that there should be a space before the last token
+     * @param node The node to report in the event of an error.
+     * @param token The token to use for the report.
+     */
+    function reportRequiredEndingSpace(
+      node: TSESTree.TSTypeLiteral,
+      token: TSESTree.Token,
+    ): void {
+      context.report({
+        node,
+        loc: token.loc,
+        messageId: 'requireSpaceBefore',
+        data: {
+          token: token.value,
+        },
+        fix(fixer) {
+          return fixer.insertTextBefore(token, ' ');
+        },
+      });
+    }
+
+    /**
+     * Determines if spacing in curly braces is valid.
+     * @param node The AST node to check.
+     * @param first The first token to check (should be the opening brace)
+     * @param second The second token to check (should be first after the opening brace)
+     * @param penultimate The penultimate token to check (should be last before closing brace)
+     * @param last The last token to check (should be closing brace)
+     */
+    function validateBraceSpacing(
+      node: TSESTree.TSTypeLiteral,
+      first: TSESTree.Token,
+      second: TSESTree.Token | TSESTree.Comment,
+      penultimate: TSESTree.Token | TSESTree.Comment,
+      last: TSESTree.Token,
+    ): void {
+      if (isTokenOnSameLine(first, second)) {
+        const firstSpaced = sourceCode.isSpaceBetween!(first, second);
+        const secondType = sourceCode.getNodeByRangeIndex(second.range[0])!
+          .type;
+
+        const openingCurlyBraceMustBeSpaced =
+          options.arraysInObjectsException &&
+          secondType === AST_NODE_TYPES.TSIndexSignature
+            ? !options.spaced
+            : options.spaced;
+
+        if (openingCurlyBraceMustBeSpaced && !firstSpaced) {
+          reportRequiredBeginningSpace(node, first);
+        }
+        if (
+          !openingCurlyBraceMustBeSpaced &&
+          firstSpaced &&
+          second.type !== AST_TOKEN_TYPES.Line
+        ) {
+          reportNoBeginningSpace(node, first);
+        }
+      }
+
+      if (isTokenOnSameLine(penultimate, last)) {
+        const shouldCheckPenultimate =
+          (options.arraysInObjectsException &&
+            isClosingBracketToken(penultimate)) ||
+          (options.objectsInObjectsException &&
+            isClosingBraceToken(penultimate));
+        const penultimateType =
+          shouldCheckPenultimate &&
+          sourceCode.getNodeByRangeIndex(penultimate.range[0])!.type;
+
+        const closingCurlyBraceMustBeSpaced =
+          (options.arraysInObjectsException &&
+            penultimateType === AST_NODE_TYPES.TSTupleType) ||
+          (options.objectsInObjectsException &&
+            penultimateType === AST_NODE_TYPES.TSTypeLiteral)
+            ? !options.spaced
+            : options.spaced;
+
+        const lastSpaced = sourceCode.isSpaceBetween!(penultimate, last);
+
+        if (closingCurlyBraceMustBeSpaced && !lastSpaced) {
+          reportRequiredEndingSpace(node, last);
+        }
+        if (!closingCurlyBraceMustBeSpaced && lastSpaced) {
+          reportNoEndingSpace(node, last);
+        }
+      }
+    }
+
+    /**
+     * Gets '}' token of an object node.
+     *
+     * Because the last token of object patterns might be a type annotation,
+     * this traverses tokens preceded by the last property, then returns the
+     * first '}' token.
+     * @param node The node to get. This node is an
+     *      ObjectExpression or an ObjectPattern. And this node has one or
+     *      more properties.
+     * @returns '}' token.
+     */
+    function getClosingBraceOfObject(
+      node: TSESTree.TSTypeLiteral,
+    ): TSESTree.Token | null {
+      const lastProperty = node.members[node.members.length - 1];
+
+      return sourceCode.getTokenAfter(lastProperty, isClosingBraceToken);
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    const rules = baseRule.create(context);
+    return {
+      ...rules,
+      TSTypeLiteral(node: TSESTree.TSTypeLiteral): void {
+        if (node.members.length === 0) {
+          return;
+        }
+
+        const first = sourceCode.getFirstToken(node)!;
+        const last = getClosingBraceOfObject(node)!;
+        const second = sourceCode.getTokenAfter(first, {
+          includeComments: true,
+        })!;
+        const penultimate = sourceCode.getTokenBefore(last, {
+          includeComments: true,
+        })!;
+
+        validateBraceSpacing(node, first, second, penultimate, last);
+      },
+    };
+  },
+});