no-object-literal-type-assertion.ts

import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/util';
import * as util from '../util';

type Options = [
  {
    allowAsParameter?: boolean;
  }
];
type MessageIds = 'unexpectedTypeAssertion';

export default util.createRule<Options, MessageIds>({
  name: 'no-object-literal-type-assertion',
  meta: {
    type: 'problem',
    docs: {
      description:
        'Forbids an object literal to appear in a type assertion expression',
      tslintRuleName: 'no-object-literal-type-assertion',
      category: 'Stylistic Issues',
      recommended: 'error',
    },
    messages: {
      unexpectedTypeAssertion:
        'Type assertion on object literals is forbidden, use a type annotation instead.',
    },
    schema: [
      {
        type: 'object',
        additionalProperties: false,
        properties: {
          allowAsParameter: {
            type: 'boolean',
          },
        },
      },
    ],
  },
  defaultOptions: [
    {
      allowAsParameter: false,
    },
  ],
  create(context, [{ allowAsParameter }]) {
    /**
     * Check whatever node should be reported
     * @param node the node to be evaluated.
     */
    function checkType(node: TSESTree.TypeNode): boolean {
      switch (node.type) {
        case AST_NODE_TYPES.TSAnyKeyword:
        case AST_NODE_TYPES.TSUnknownKeyword:
          return false;
        case AST_NODE_TYPES.TSTypeReference:
          // Ignore `as const` and `<const>` (#166)
          return (
            node.typeName.type === AST_NODE_TYPES.Identifier &&
            node.typeName.name !== 'const'
          );
        default:
          return true;
      }
    }

    return {
      'TSTypeAssertion, TSAsExpression'(
        node: TSESTree.TSTypeAssertion | TSESTree.TSAsExpression,
      ) {
        if (
          allowAsParameter &&
          node.parent &&
          (node.parent.type === AST_NODE_TYPES.NewExpression ||
            node.parent.type === AST_NODE_TYPES.CallExpression)
        ) {
          return;
        }

        if (
          checkType(node.typeAnnotation) &&
          node.expression.type === AST_NODE_TYPES.ObjectExpression
        ) {
          context.report({
            node,
            messageId: 'unexpectedTypeAssertion',
          });
        }
      },
    };
  },
});