Fix type inconsistencies/casting

Author: zachbryant

src/fixer.ts

@@ -1,34 +1,28 @@
 import { TSESLint } from '@typescript-eslint/utils'
 import { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint'
 
-import { AllRuleOptions, CreateReporterArgs, Node, SourceCode, TSType } from './types'
+import { AllRuleOptions, CreateReporterArgs, NodeOrToken, SourceCode } from './types'
 import { getMemoized, memoize } from './utils/memo'
 import { getBodyRange, getFixedBodyText } from './utils/sourcecode'
 
 export const getFixerFunction = (
   baseMemoKey: string,
   createReporterArgs: Pick<CreateReporterArgs<string, AllRuleOptions>, 'context'>,
-  body: TSType[],
-  sortedBody: TSType[],
+  body: NodeOrToken[],
+  sortedBody: NodeOrToken[],
 ): ReportFixFunction =>
   function* (fixer: TSESLint.RuleFixer) {
     const sourceCode = createReporterArgs.context.sourceCode as SourceCode
 
     const bodyRange = memoize(`bodyRange_${baseMemoKey}`, () =>
-      getBodyRange(sourceCode, body as unknown as Node[]),
+      getBodyRange(sourceCode, body),
     )
 
     const fixedBodyTextMemoKey = `fixedBodyText_${baseMemoKey}`
     // Replace the entire body with the sorted body
     const fixedBodyText =
       getMemoized(fixedBodyTextMemoKey) ??
-      memoize(fixedBodyTextMemoKey, () =>
-        getFixedBodyText(
-          sourceCode,
-          sortedBody as unknown as Node[],
-          body as unknown as Node[],
-        ),
-      )
+      memoize(fixedBodyTextMemoKey, () => getFixedBodyText(sourceCode, sortedBody, body))
 
     yield fixer.replaceTextRange(bodyRange, fixedBodyText)
   }

src/plugin.ts

@@ -1,9 +1,13 @@
-import { TSESTree } from '@typescript-eslint/utils'
-
 import { getOptions } from './common/options'
 import { getFixerFunction } from './fixer'
 import { reportBodyNodes, reportParentNode } from './report'
-import { AllRuleOptions, CreateReporterArgs, NodePositionInfo, TSType } from './types'
+import {
+  AllRuleOptions,
+  CreateReporterArgs,
+  Declaration,
+  NodeOrToken,
+  NodePositionInfo,
+} from './types'
 import { getPropertyIsOptional, getPropertyName } from './utils/ast'
 import { compareFn } from './utils/compare'
 import { memoize } from './utils/memo'
@@ -13,9 +17,9 @@ import { getUnsortedInfo } from './utils/reportUtils'
  * Returns the body sorted according to the options and sorting function.
  */
 function getSortedBody(
-  body: TSType[],
+  body: NodeOrToken[],
   isRequiredFirst: boolean,
-  sortFunction: (a: TSType, b: TSType) => number,
+  sortFunction: (a: NodeOrToken, b: NodeOrToken) => number,
 ) {
   return isRequiredFirst
     ? [
@@ -39,11 +43,11 @@ export function createReporter(
     createReporterArgs.context,
   )
   const compare = compareFn(isAscending, isInsensitive, isNatural)
-  const sortFunction = (a: TSType, b: TSType) =>
+  const sortFunction = (a: NodeOrToken, b: NodeOrToken) =>
     compare(getPropertyName(a), getPropertyName(b))
 
   // Reporter function
-  return (bodyParent: TSESTree.Node, body: TSType[]) => {
+  return (bodyParent: Declaration, body: NodeOrToken[]) => {
     if (body.length < 2) {
       return
     }
@@ -56,13 +60,13 @@ export function createReporter(
       source: sourceCode.getText(), // Disambiguator when same body on both a type and interface
     })
 
-    const sortedBody: TSType[] = memoize(`sortedBody_${baseMemoKey}`, () =>
+    const sortedBody = memoize(`sortedBody_${baseMemoKey}`, () =>
       getSortedBody(body, isRequiredFirst, sortFunction),
     )
-    const nodePositions: Map<TSType, NodePositionInfo> = memoize(
+    const nodePositions: Map<NodeOrToken, NodePositionInfo> = memoize(
       `nodePositions_${baseMemoKey}`,
       () =>
-        new Map<TSType, NodePositionInfo>(
+        new Map<NodeOrToken, NodePositionInfo>(
           body.map((n, index) => [
             n,
             { initialIndex: index, finalIndex: sortedBody.indexOf(n) },
@@ -80,14 +84,9 @@ export function createReporter(
       const fixerFunction = memoize(fixerFunctionMemoKey, () =>
         getFixerFunction(baseMemoKey, createReporterArgs, body, sortedBody),
       )
-      reportParentNode(createReporterArgs, bodyParent, unsortedCount, fixerFunction)
-      reportBodyNodes(
-        createReporterArgs,
-        nodePositions,
-        sortedBody,
-        finalIndicesToReport,
-        fixerFunction,
-      )
+
+      reportParentNode(createReporterArgs, bodyParent.loc, unsortedCount, fixerFunction)
+      reportBodyNodes(createReporterArgs, nodePositions, sortedBody, finalIndicesToReport)
     }
   }
 }

src/report.ts

@@ -4,7 +4,12 @@ import { TSESTree } from '@typescript-eslint/utils'
 import { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint'
 
 import { getOptions } from './common/options'
-import { AllRuleOptions, CreateReporterArgs, NodePositionInfo, TSType } from './types'
+import {
+  AllRuleOptions,
+  CreateReporterArgs,
+  NodeOrToken,
+  NodePositionInfo,
+} from './types'
 import { getPropertyName } from './utils/ast'
 import { getDeprecationMessage } from './utils/reportUtils'
 
@@ -16,12 +21,12 @@ export function reportParentNode(
     CreateReporterArgs<string, AllRuleOptions>,
     'createReportPropertiesObject'
   >,
-  bodyParent: TSESTree.Node,
+  _loc: TSESTree.SourceLocation,
   unsortedCount: number,
   fixerFunction: ReportFixFunction,
 ) {
   const { context, createReportParentObject } = createReporterArgs
-  const { loc, messageId } = createReportParentObject(bodyParent)
+  const { loc, messageId } = createReportParentObject(_loc)
   context.report({
     loc,
     messageId,
@@ -42,8 +47,8 @@ export function reportBodyNodes(
     CreateReporterArgs<string, AllRuleOptions>,
     'createReportParentObject'
   >,
-  nodePositions: Map<TSType, NodePositionInfo>,
-  sortedBody: TSType[],
+  nodePositions: Map<NodeOrToken, NodePositionInfo>,
+  sortedBody: NodeOrToken[],
   finalIndicesToReport: boolean[],
   fixerFunction: ReportFixFunction,
 ) {
@@ -54,7 +59,7 @@ export function reportBodyNodes(
   for (const [node, { finalIndex }] of nodePositions.entries()) {
     // If the node is not in the correct position, report it
     if (finalIndicesToReport[finalIndex]) {
-      const { loc, messageId } = createReportPropertiesObject(node)
+      const { loc, messageId } = createReportPropertiesObject(node.loc)
 
       // Sanity check
       assert(loc, 'createReportObject return value must include a node location')

src/rules/enum.ts

@@ -82,11 +82,11 @@ export const rule = createRule<errorMessageKeys, RuleOptions>({
   create(context) {
     const compareNodeListAndReport = createReporter({
       context,
-      createReportPropertiesObject: ({ loc }: TSESTree.Node) => ({
+      createReportPropertiesObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderBody' as any,
       }),
-      createReportParentObject: ({ loc }: TSESTree.Node) => ({
+      createReportParentObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderParent' as any,
       }),

src/rules/interface.ts

@@ -88,11 +88,11 @@ export const rule = createRule<errorMessageKeys, RuleOptions>({
   create(context) {
     const compareNodeListAndReport = createReporter({
       context,
-      createReportPropertiesObject: ({ loc }: TSESTree.Node) => ({
+      createReportPropertiesObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderBody' as any,
       }),
-      createReportParentObject: ({ loc }: TSESTree.Node) => ({
+      createReportParentObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderParent' as any,
       }),

src/rules/string-enum.ts

@@ -88,11 +88,11 @@ export const rule = createRule<errorMessageKeys, RuleOptions>({
   create(context) {
     const compareNodeListAndReport = createReporter({
       context,
-      createReportPropertiesObject: ({ loc }: TSESTree.Node) => ({
+      createReportPropertiesObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderBody' as any,
       }),
-      createReportParentObject: ({ loc }: TSESTree.Node) => ({
+      createReportParentObject: (loc: TSESTree.SourceLocation) => ({
         loc,
         messageId: 'invalidOrderParent' as any,
       }),

src/types/node.ts

@@ -1,5 +1,8 @@
 import { TSESTree } from '@typescript-eslint/utils'
 
-export type Node = Omit<TSESTree.Node, 'type'> & { type: any; value: string }
-export type TSType = TSESTree.TypeElement | TSESTree.TSEnumMember
+export type NodeOrToken = (TSESTree.Node | TSESTree.Token) & { parent?: NodeOrToken }
+export type Declaration =
+  | TSESTree.TSEnumDeclaration
+  | TSESTree.TSInterfaceDeclaration
+  | TSESTree.TSTypeLiteral
 export type NodePositionInfo = { initialIndex: number; finalIndex: number }

src/types/report.ts

@@ -1,15 +1,15 @@
 import { TSESTree } from '@typescript-eslint/utils'
 import {
-  SourceCode as Lib_SourceCode,
   RuleContext as UtilRuleContext,
+  SourceCode as Lib_SourceCode,
 } from '@typescript-eslint/utils/ts-eslint'
 
 export type SourceCode = Lib_SourceCode & {
   lineStartIndices: number[]
 }
 
 export type ReportObjectCreator = <MessageIds extends string>(
-  node: TSESTree.Node,
+  loc: TSESTree.SourceLocation,
 ) => {
   readonly loc: TSESTree.SourceLocation
   readonly messageId: MessageIds

src/utils/ast.ts

@@ -1,6 +1,7 @@
+import { NodeOrToken } from 'src/types'
+
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils'
 
-import { TSType } from 'types'
 import { indexSignature } from './common'
 
 export function getObjectBody(
@@ -18,7 +19,7 @@ export function getObjectBody(
   }
 }
 
-function getProperty(node: TSESTree.Node) {
+function getProperty(node: NodeOrToken) {
   switch (node.type) {
     case AST_NODE_TYPES.TSIndexSignature: {
       const [identifier] = node.parameters
@@ -72,7 +73,7 @@ function getProperty(node: TSESTree.Node) {
  *     let a = {[tag`b`]: 1}     // => undefined
  *     let a = {[`${b}`]: 1}     // => undefined
  */
-export function getPropertyName(node: TSType) {
+export function getPropertyName(node: NodeOrToken) {
   const property = getProperty(node as TSESTree.Node)
 
   switch (property?.type) {
@@ -88,11 +89,14 @@ export function getPropertyName(node: TSType) {
 }
 
 // Returns whether a method or property signature is optional.
-export function getPropertyIsOptional(node: TSType) {
+export function getPropertyIsOptional(node: NodeOrToken) {
   switch (node.type) {
     case AST_NODE_TYPES.TSMethodSignature:
     case AST_NODE_TYPES.TSPropertySignature:
-      return Boolean(node.optional)
+      return Boolean(
+        (node as TSESTree.TSMethodSignature | TSESTree.TSPropertySignature).optional,
+      )
+
     default:
       return false
   }

src/utils/memo.ts

@@ -1,7 +1,7 @@
 const memo: Record<string, any> = {}
 
 // Getting strange test failures? Could be this! Disable and try again.
-export function memoize(key: string, valueFn: () => any): any {
+export function memoize<T>(key: string, valueFn: () => T): T {
   if (hasMemoized(key)) {
     return memo[key]
   }

src/utils/reportUtils.ts

@@ -1,9 +1,4 @@
-import { PLUGIN_NAME } from 'config/constants'
-import { name as enumRuleName } from 'rules/enum'
-import { name as enumRuleNameDeprecated } from 'rules/string-enum'
-import { NodePositionInfo, TSType } from 'types'
-
-import { getRuleDocsUrl } from './rule'
+import { NodeOrToken, NodePositionInfo } from '../types'
 
 /**
  * Check if the node is locally sorted or not.
@@ -12,8 +7,8 @@ import { getRuleDocsUrl } from './rule'
  *  before 'b' even though they're both positioned wrongly.
  */
 export function shouldReportUnsorted(
-  sortedBody: TSType[],
-  unsortedBody: TSType[],
+  sortedBody: NodeOrToken[],
+  unsortedBody: NodeOrToken[],
   nodeInfo: NodePositionInfo,
 ) {
   const { initialIndex, finalIndex } = nodeInfo
@@ -27,9 +22,9 @@ export function shouldReportUnsorted(
 
 // Helpful metadata on nodes to report/skip reporting
 export function getUnsortedInfo(
-  sortedBody: TSType[],
-  unsortedBody: TSType[],
-  nodePositions: Map<TSType, NodePositionInfo>,
+  sortedBody: NodeOrToken[],
+  unsortedBody: NodeOrToken[],
+  nodePositions: Map<NodeOrToken, NodePositionInfo>,
 ) {
   const finalIndicesToReport = new Array(sortedBody.length).fill(false)
   const unsortedCount = Array.from(nodePositions.entries()).reduce(