📄 `prefer-as-const`¶

📊 Analysis Summary¶

Metric	Count
🔧 Functions	2
📦 Imports	4

📚 Table of Contents¶

Default Export
Imports
Functions

🛠️ File Location:¶

📂 packages/eslint-plugin/src/rules/prefer-as-const.ts

📤 Default Export¶

export default createRule({ ... })

Property	Value
`name`	'prefer-as-const'
`meta.type`	'suggestion'
`meta.docs.description`	'Enforce the use of `as const` over literal type'
`meta.docs.recommended`	'recommended'
`meta.fixable`	'code'
`meta.hasSuggestions`	true
`meta.messages.preferConstAssertion`	'Expected a `const` instead of a literal type assertion.'
`meta.messages.variableConstAssertion`	'Expected a `const` assertion instead of a literal type annotation.'
`meta.messages.variableSuggest`	'You should use `as const` instead of type annotation.'
`meta.schema`	[]
`defaultOptions`	[]

Entry point: create — documented under Functions.

📦 Imports¶

Name	Source
`TSESLint`	`@typescript-eslint/utils`
`TSESTree`	`@typescript-eslint/utils`
`AST_NODE_TYPES`	`@typescript-eslint/utils`
`createRule`	`../util`

Functions¶

`create(context: any): { PropertyDefinition(node: any): void; TSAsExpression(node:…`¶

Parameters:

context any

Returns: { PropertyDefinition(node: any): void; TSAsExpression(node: any): void; TSTypeAssertion(node: any): void; VariableDeclarator(node: any): void; }

Calls:

context.report
fixer.replaceText
fixer.remove
fixer.insertTextAfter
compareTypes

Code

create(context) {
    function compareTypes(
      valueNode: TSESTree.Expression,
      typeNode: TSESTree.TypeNode,
      canFix: boolean,
    ): void {
      if (
        valueNode.type === AST_NODE_TYPES.Literal &&
        typeNode.type === AST_NODE_TYPES.TSLiteralType &&
        typeNode.literal.type === AST_NODE_TYPES.Literal &&
        valueNode.raw === typeNode.literal.raw
      ) {
        if (canFix) {
          context.report({
            node: typeNode,
            messageId: 'preferConstAssertion',
            fix: fixer => fixer.replaceText(typeNode, 'const'),
          });
        } else {
          context.report({
            node: typeNode,
            messageId: 'variableConstAssertion',
            suggest: [
              {
                messageId: 'variableSuggest',
                fix: (fixer): TSESLint.RuleFix[] => [
                  fixer.remove(typeNode.parent),
                  fixer.insertTextAfter(valueNode, ' as const'),
                ],
              },
            ],
          });
        }
      }
    }

    return {
      PropertyDefinition(node): void {
        if (node.value && node.typeAnnotation) {
          compareTypes(node.value, node.typeAnnotation.typeAnnotation, false);
        }
      },
      TSAsExpression(node): void {
        compareTypes(node.expression, node.typeAnnotation, true);
      },
      TSTypeAssertion(node): void {
        compareTypes(node.expression, node.typeAnnotation, true);
      },
      VariableDeclarator(node): void {
        if (node.init && node.id.typeAnnotation) {
          compareTypes(node.init, node.id.typeAnnotation.typeAnnotation, false);
        }
      },
    };
  }

Internal helpers¶

Declared inside another function in this file.

`compareTypes(valueNode: TSESTree.Expression, typeNode: TSESTree.TypeNode, canFix: boolean): void`¶