feat: autofix errors

Author: hugop95

rules/sort-switch-case.ts

@@ -250,6 +250,7 @@ export default createEslintRule<Options, MESSAGE_ID>({
               : makeFixes({
                   sortedNodes: sortedSortingNodeGroupsForBlockSort,
                   nodes: sortingNodeGroupsForBlockSortFlat,
+                  hasCommentAboveMissing: false,
                   sourceCode,
                   fixer,
                 }),

utils/make-comment-above-fixes.ts

@@ -0,0 +1,136 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+import type {
+  DeprecatedCustomGroupsOption,
+  CustomGroupsOption,
+  GroupsOptions,
+} from '../types/common-options'
+import type { SortingNode } from '../types/sorting-node'
+
+import { getCommentAboveThatShouldExist } from './get-comment-above-that-should-exist'
+import { isCommentAboveOption } from './is-comment-above-option'
+import { getCommentsBefore } from './get-comments-before'
+import { getGroupIndex } from './get-group-index'
+
+interface MakeCommentAboveFixesParameters {
+  options: {
+    customGroups?: DeprecatedCustomGroupsOption | CustomGroupsOption
+    groups: GroupsOptions<string>
+  }
+  sourceCode: TSESLint.SourceCode
+  sortedNodes: SortingNode[]
+  fixer: TSESLint.RuleFixer
+}
+
+export let makeCommentAboveFixes = ({
+  sortedNodes,
+  sourceCode,
+  options,
+  fixer,
+}: MakeCommentAboveFixesParameters): TSESLint.RuleFix[] => {
+  let allAutoAddedComments = new Set(
+    options.groups
+      .filter(group => isCommentAboveOption(group))
+      .map(({ commentAbove }) => commentAbove),
+  )
+
+  let fixes: TSESLint.RuleFix[] = []
+
+  let firstNodeFixes = makeCommentAboveFix({
+    nextSortedSortingNode: sortedNodes[0]!,
+    sortedSortingNode: null,
+    allAutoAddedComments,
+    sourceCode,
+    options,
+    fixer,
+  })
+  fixes.push(...firstNodeFixes)
+
+  for (let i = 0; i < sortedNodes.length - 1; i++) {
+    let sortedSortingNode = sortedNodes.at(i) ?? null
+    let nextSortedSortingNode = sortedNodes.at(i + 1)!
+
+    let nodeFixes = makeCommentAboveFix({
+      nextSortedSortingNode,
+      allAutoAddedComments,
+      sortedSortingNode,
+      sourceCode,
+      options,
+      fixer,
+    })
+    fixes.push(...nodeFixes)
+  }
+
+  return fixes
+}
+
+let makeCommentAboveFix = ({
+  nextSortedSortingNode,
+  allAutoAddedComments,
+  sortedSortingNode,
+  sourceCode,
+  options,
+  fixer,
+}: {
+  sortedSortingNode: SortingNode | null
+  nextSortedSortingNode: SortingNode
+  allAutoAddedComments: Set<string>
+} & Pick<
+  MakeCommentAboveFixesParameters,
+  'sourceCode' | 'options' | 'fixer'
+>): TSESLint.RuleFix[] => {
+  let leftGroupIndex = sortedSortingNode
+    ? getGroupIndex(options.groups, sortedSortingNode)
+    : -1
+  let rightGroupIndex = getGroupIndex(options.groups, nextSortedSortingNode)
+
+  let commentAboveThatShouldExist = getCommentAboveThatShouldExist({
+    options: {
+      ...options,
+      groups: options.groups,
+    },
+    sortingNode: nextSortedSortingNode,
+    rightGroupIndex,
+    leftGroupIndex,
+    sourceCode,
+  })
+  let commentsBefore = getCommentsBefore({
+    node: nextSortedSortingNode.node,
+    sourceCode,
+  })
+
+  let autoAddedCommentsAboveToRemove = commentsBefore
+    .filter(
+      comment =>
+        !commentAboveThatShouldExist?.comment ||
+        comment.value.slice(1) !== commentAboveThatShouldExist.comment,
+    )
+    .filter(
+      comment =>
+        comment.type === 'Line' &&
+        allAutoAddedComments.has(comment.value.slice(1)),
+    )
+
+  let fixes: TSESLint.RuleFix[] = []
+  for (let autoAddedCommentAboveToRemove of autoAddedCommentsAboveToRemove) {
+    let nextToken = sourceCode.getTokenAfter(autoAddedCommentAboveToRemove)
+    let rangeEnd = nextToken
+      ? nextToken.range[0]
+      : autoAddedCommentAboveToRemove.range[1]
+    fixes.push(
+      fixer.removeRange([autoAddedCommentAboveToRemove.range[0], rangeEnd]),
+    )
+  }
+
+  if (commentAboveThatShouldExist && !commentAboveThatShouldExist.exists) {
+    let nodeToPutCommentBefore = commentsBefore[0] ?? nextSortedSortingNode.node
+    fixes.push(
+      fixer.insertTextBeforeRange(
+        nodeToPutCommentBefore.range,
+        `// ${commentAboveThatShouldExist.comment}\n`,
+      ),
+    )
+  }
+
+  return fixes
+}

utils/make-fixes.ts

@@ -12,6 +12,7 @@ import type { SortingNode } from '../types/sorting-node'
 
 import { makeNewlinesBetweenFixes } from './make-newlines-between-fixes'
 import { makeCommentAfterFixes } from './make-comment-after-fixes'
+import { makeCommentAboveFixes } from './make-comment-above-fixes'
 import { makeOrderFixes } from './make-order-fixes'
 
 export interface MakeFixesParameters<T extends SortingNode> {
@@ -24,6 +25,7 @@ export interface MakeFixesParameters<T extends SortingNode> {
   newlinesBetweenValueGetter?: NewlinesBetweenValueGetter<T>
   ignoreFirstNodeHighestBlockComment?: boolean
   sourceCode: TSESLint.SourceCode
+  hasCommentAboveMissing: boolean
   fixer: TSESLint.RuleFixer
   sortedNodes: T[]
   nodes: T[]
@@ -32,6 +34,7 @@ export interface MakeFixesParameters<T extends SortingNode> {
 export let makeFixes = <T extends SortingNode>({
   ignoreFirstNodeHighestBlockComment,
   newlinesBetweenValueGetter,
+  hasCommentAboveMissing,
   sortedNodes,
   sourceCode,
   options,
@@ -53,26 +56,43 @@ export let makeFixes = <T extends SortingNode>({
     nodes,
     fixer,
   })
-  if (
-    commentAfterFixes.length > 0 ||
-    !options?.groups ||
-    !options.newlinesBetween
-  ) {
+  if (commentAfterFixes.length > 0) {
     return [...orderFixes, ...commentAfterFixes]
   }
 
-  let newlinesFixes = makeNewlinesBetweenFixes({
+  if (options?.groups && options.newlinesBetween) {
+    let newlinesFixes = makeNewlinesBetweenFixes({
+      options: {
+        ...options,
+        newlinesBetween: options.newlinesBetween,
+        groups: options.groups,
+      },
+      newlinesBetweenValueGetter,
+      sortedNodes,
+      sourceCode,
+      fixer,
+      nodes,
+    })
+    if (newlinesFixes.length > 0) {
+      return [...orderFixes, ...newlinesFixes]
+    }
+  }
+
+  if (orderFixes.length > 0) {
+    return orderFixes
+  }
+
+  if (!hasCommentAboveMissing || !options?.groups) {
+    return []
+  }
+
+  return makeCommentAboveFixes({
     options: {
       ...options,
-      newlinesBetween: options.newlinesBetween,
       groups: options.groups,
     },
-    newlinesBetweenValueGetter,
     sortedNodes,
     sourceCode,
     fixer,
-    nodes,
   })
-
-  return [...orderFixes, ...newlinesFixes]
 }

utils/report-errors.ts

@@ -71,6 +71,7 @@ export let reportErrors = <MessageIds extends string, T extends SortingNode>({
       },
       fix: (fixer: TSESLint.RuleFixer) =>
         makeFixes({
+          hasCommentAboveMissing: !!commentAboveMissing,
           ignoreFirstNodeHighestBlockComment,
           newlinesBetweenValueGetter,
           sortedNodes,