typescript-eslint · JoshuaKGoldberg · Oct 17, 2024 · Aug 20, 2024 · Oct 11, 2024
diff --git a/eslint.config.mjs b/eslint.config.mjs
@@ -609,6 +609,7 @@ export default tseslint.config(
       'packages/rule-schema-to-typescript-types/src/**/*.ts',
       'packages/rule-tester/{src,tests,typings}/**/*.ts',
       'packages/scope-manager/{src,tests}/**/*.ts',
+      'packages/type-utils/{src,tests,typings}/**/*.ts',
       'packages/types/{src,tools}/**/*.ts',
       'packages/typescript-eslint/{src,tests}/**/*.ts',
       'packages/utils/src/**/*.ts',

diff --git a/packages/type-utils/src/TypeOrValueSpecifier.ts b/packages/type-utils/src/TypeOrValueSpecifier.ts
@@ -1,7 +1,8 @@
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
-import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
+import * as tsutils from 'ts-api-utils';
+
 import { specifierNameMatches } from './typeOrValueSpecifiers/specifierNameMatches';
 import { typeDeclaredInFile } from './typeOrValueSpecifiers/typeDeclaredInFile';
 import { typeDeclaredInLib } from './typeOrValueSpecifiers/typeDeclaredInLib';
@@ -67,32 +68,30 @@ export type TypeOrValueSpecifier =
   | string;
 
 export const typeOrValueSpecifiersSchema = {
-  type: 'array',
   items: {
     oneOf: [
       {
         type: 'string',
       },
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           from: {
-            type: 'string',
             enum: ['file'],
+            type: 'string',
           },
           name: {
             oneOf: [
               {
                 type: 'string',
               },
               {
-                type: 'array',
-                minItems: 1,
-                uniqueItems: true,
                 items: {
                   type: 'string',
                 },
+                minItems: 1,
+                type: 'array',
+                uniqueItems: true,
               },
             ],
           },
@@ -101,53 +100,53 @@ export const typeOrValueSpecifiersSchema = {
           },
         },
         required: ['from', 'name'],
+        type: 'object',
       },
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           from: {
-            type: 'string',
             enum: ['lib'],
+            type: 'string',
           },
           name: {
             oneOf: [
               {
                 type: 'string',
               },
               {
-                type: 'array',
-                minItems: 1,
-                uniqueItems: true,
                 items: {
                   type: 'string',
                 },
+                minItems: 1,
+                type: 'array',
+                uniqueItems: true,
               },
             ],
           },
         },
         required: ['from', 'name'],
+        type: 'object',
       },
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           from: {
-            type: 'string',
             enum: ['package'],
+            type: 'string',
           },
           name: {
             oneOf: [
               {
                 type: 'string',
               },
               {
-                type: 'array',
-                minItems: 1,
-                uniqueItems: true,
                 items: {
                   type: 'string',
                 },
+                minItems: 1,
+                type: 'array',
+                uniqueItems: true,
               },
             ],
           },
@@ -156,9 +155,11 @@ export const typeOrValueSpecifiersSchema = {
           },
         },
         required: ['from', 'name', 'package'],
+        type: 'object',
       },
     ],
   },
+  type: 'array',
 } as const satisfies JSONSchema4;
 
 export function typeMatchesSpecifier(

diff --git a/packages/type-utils/src/builtinSymbolLikes.ts b/packages/type-utils/src/builtinSymbolLikes.ts
@@ -73,10 +73,10 @@ export function isReadonlyTypeLike(
   program: ts.Program,
   type: ts.Type,
   predicate?: (
-    subType: ts.Type & {
+    subType: {
       aliasSymbol: ts.Symbol;
       aliasTypeArguments: readonly ts.Type[];
-    },
+    } & ts.Type,
   ) => boolean,
 ): boolean {
   return isBuiltinTypeAliasLike(program, type, subtype => {
@@ -89,10 +89,10 @@ export function isBuiltinTypeAliasLike(
   program: ts.Program,
   type: ts.Type,
   predicate: (
-    subType: ts.Type & {
+    subType: {
       aliasSymbol: ts.Symbol;
       aliasTypeArguments: readonly ts.Type[];
-    },
+    } & ts.Type,
   ) => boolean,
 ): boolean {
   return isBuiltinSymbolLikeRecurser(program, type, subtype => {
@@ -105,10 +105,10 @@ export function isBuiltinTypeAliasLike(
     if (
       isSymbolFromDefaultLibrary(program, aliasSymbol) &&
       predicate(
-        subtype as ts.Type & {
+        subtype as {
           aliasSymbol: ts.Symbol;
           aliasTypeArguments: readonly ts.Type[];
-        },
+        } & ts.Type,
       )
     ) {
       return true;
@@ -121,7 +121,7 @@ export function isBuiltinTypeAliasLike(
 export function isBuiltinSymbolLike(
   program: ts.Program,
   type: ts.Type,
-  symbolName: string | string[],
+  symbolName: string[] | string,
 ): boolean {
   return isBuiltinSymbolLikeRecurser(program, type, subType => {
     const symbol = subType.getSymbol();

diff --git a/packages/type-utils/src/getContextualType.ts b/packages/type-utils/src/getContextualType.ts
@@ -38,7 +38,7 @@ export function getContextualType(
     // is RHS of assignment
     return checker.getTypeAtLocation(parent.left);
   } else if (
-    ![ts.SyntaxKind.TemplateSpan, ts.SyntaxKind.JsxExpression].includes(
+    ![ts.SyntaxKind.JsxExpression, ts.SyntaxKind.TemplateSpan].includes(
       parent.kind,
     )
   ) {

diff --git a/packages/type-utils/src/index.ts b/packages/type-utils/src/index.ts
@@ -11,8 +11,8 @@ export * from './isUnsafeAssignment';
 export * from './predicates';
 export * from './propertyTypes';
 export * from './requiresQuoting';
-export * from './TypeOrValueSpecifier';
 export * from './typeFlagUtils';
+export * from './TypeOrValueSpecifier';
 export {
   getDecorators,
   getModifiers,

diff --git a/packages/type-utils/src/isTypeReadonly.ts b/packages/type-utils/src/isTypeReadonly.ts
@@ -1,10 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+
+import { ESLintUtils } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
-import { getTypeOfPropertyOfType } from './propertyTypes';
 import type { TypeOrValueSpecifier } from './TypeOrValueSpecifier';
+
+import { getTypeOfPropertyOfType } from './propertyTypes';
 import {
   typeMatchesSomeSpecifier,
   typeOrValueSpecifiersSchema,
@@ -20,27 +22,27 @@ const enum Readonlyness {
 }
 
 export interface ReadonlynessOptions {
-  readonly treatMethodsAsReadonly?: boolean;
   readonly allow?: TypeOrValueSpecifier[];
+  readonly treatMethodsAsReadonly?: boolean;
 }
 
 export const readonlynessOptionsSchema = {
-  type: 'object',
   additionalProperties: false,
   properties: {
+    allow: typeOrValueSpecifiersSchema,
     treatMethodsAsReadonly: {
       type: 'boolean',
     },
-    allow: typeOrValueSpecifiersSchema,
   },
+  type: 'object',
 } satisfies JSONSchema4;
 
 export const readonlynessOptionsDefaults: ReadonlynessOptions = {
-  treatMethodsAsReadonly: false,
   allow: [],
+  treatMethodsAsReadonly: false,
 };
 
-function hasSymbol(node: ts.Node): node is ts.Node & { symbol: ts.Symbol } {
+function hasSymbol(node: ts.Node): node is { symbol: ts.Symbol } & ts.Node {
   return Object.hasOwn(node, 'symbol');
 }
 

diff --git a/packages/type-utils/src/isUnsafeAssignment.ts b/packages/type-utils/src/isUnsafeAssignment.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type * as ts from 'typescript';
 
 import { isTypeAnyType, isTypeUnknownType } from './predicates';
 
@@ -20,7 +21,7 @@ export function isUnsafeAssignment(
   receiver: ts.Type,
   checker: ts.TypeChecker,
   senderNode: TSESTree.Node | null,
-): false | { sender: ts.Type; receiver: ts.Type } {
+): { receiver: ts.Type; sender: ts.Type } | false {
   return isUnsafeAssignmentWorker(
     type,
     receiver,
@@ -36,15 +37,15 @@ function isUnsafeAssignmentWorker(
   checker: ts.TypeChecker,
   senderNode: TSESTree.Node | null,
   visited: Map<ts.Type, Set<ts.Type>>,
-): false | { sender: ts.Type; receiver: ts.Type } {
+): { receiver: ts.Type; sender: ts.Type } | false {
   if (isTypeAnyType(type)) {
     // Allow assignment of any ==> unknown.
     if (isTypeUnknownType(receiver)) {
       return false;
     }
 
     if (!isTypeAnyType(receiver)) {
-      return { sender: type, receiver };
+      return { receiver, sender: type };
     }
   }
 
@@ -107,7 +108,7 @@ function isUnsafeAssignmentWorker(
         visited,
       );
       if (unsafe) {
-        return { sender: type, receiver };
+        return { receiver, sender: type };
       }
     }
 

diff --git a/packages/type-utils/src/typeOrValueSpecifiers/specifierNameMatches.ts b/packages/type-utils/src/typeOrValueSpecifiers/specifierNameMatches.ts
@@ -1,6 +1,7 @@
-import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
+import * as tsutils from 'ts-api-utils';
+
 export function specifierNameMatches(
   type: ts.Type,
   names: string[] | string,

diff --git a/packages/type-utils/src/typeOrValueSpecifiers/typeDeclaredInFile.ts b/packages/type-utils/src/typeOrValueSpecifiers/typeDeclaredInFile.ts
@@ -1,7 +1,7 @@
-import path from 'node:path';
+import type * as ts from 'typescript';
 
 import { getCanonicalFileName } from '@typescript-eslint/typescript-estree';
-import type * as ts from 'typescript';
+import path from 'node:path';
 
 export function typeDeclaredInFile(
   relativePath: string | undefined,

diff --git a/packages/type-utils/tests/TypeOrValueSpecifier.test.ts b/packages/type-utils/tests/TypeOrValueSpecifier.test.ts
@@ -1,10 +1,11 @@
-import path from 'node:path';
+import type { TSESTree } from '@typescript-eslint/utils';
 
 import { parseForESLint } from '@typescript-eslint/parser';
-import type { TSESTree } from '@typescript-eslint/utils';
 import Ajv from 'ajv';
+import path from 'node:path';
+
+import type { TypeOrValueSpecifier } from '../src/TypeOrValueSpecifier';
 
-import type { TypeOrValueSpecifier } from '../src';
 import { typeMatchesSpecifier, typeOrValueSpecifiersSchema } from '../src';
 
 describe('TypeOrValueSpecifier', () => {
@@ -130,8 +131,8 @@ describe('TypeOrValueSpecifier', () => {
       const rootDir = path.join(__dirname, 'fixtures');
       const { ast, services } = parseForESLint(code, {
         disallowAutomaticSingleRunInference: true,
-        project: './tsconfig.json',
         filePath: path.join(rootDir, 'file.ts'),
+        project: './tsconfig.json',
         tsconfigRootDir: rootDir,
       });
       const type = services

diff --git a/packages/type-utils/tests/containsAllTypesByName.test.ts b/packages/type-utils/tests/containsAllTypesByName.test.ts
@@ -1,9 +1,9 @@
-import path from 'node:path';
-
-import { parseForESLint } from '@typescript-eslint/parser';
 import type { TSESTree } from '@typescript-eslint/typescript-estree';
 import type * as ts from 'typescript';
 
+import { parseForESLint } from '@typescript-eslint/parser';
+import path from 'node:path';
+
 import { containsAllTypesByName } from '../src';
 import { expectToHaveParserServices } from './test-utils/expectToHaveParserServices';
 
@@ -13,8 +13,8 @@ describe('containsAllTypesByName', () => {
   function getType(code: string): ts.Type {
     const { ast, services } = parseForESLint(code, {
       disallowAutomaticSingleRunInference: true,
-      project: './tsconfig.json',
       filePath: path.join(rootDir, 'file.ts'),
+      project: './tsconfig.json',
       tsconfigRootDir: rootDir,
     });
     expectToHaveParserServices(services);
@@ -68,7 +68,7 @@ describe('containsAllTypesByName', () => {
       const result = containsAllTypesByName(
         type,
         false,
-        new Set(['Promise', 'Object']),
+        new Set(['Object', 'Promise']),
         matchAnyInstead,
       );
       expect(result).toBe(expected);

diff --git a/packages/type-utils/tests/getTypeName.test.ts b/packages/type-utils/tests/getTypeName.test.ts
@@ -1,9 +1,9 @@
-import path from 'node:path';
-
-import { parseForESLint } from '@typescript-eslint/parser';
 import type { TSESTree } from '@typescript-eslint/typescript-estree';
 import type * as ts from 'typescript';
 
+import { parseForESLint } from '@typescript-eslint/parser';
+import path from 'node:path';
+
 import { getTypeName } from '../src';
 import { expectToHaveParserServices } from './test-utils/expectToHaveParserServices';
 
@@ -13,8 +13,8 @@ describe('getTypeName', () => {
 
     const { ast, services } = parseForESLint(code, {
       disallowAutomaticSingleRunInference: true,
-      project: './tsconfig.json',
       filePath: path.join(rootDir, 'file.ts'),
+      project: './tsconfig.json',
       tsconfigRootDir: rootDir,
     });
     expectToHaveParserServices(services);
@@ -25,7 +25,7 @@ describe('getTypeName', () => {
   }
 
   function runTest(code: string, expected: string): void {
-    const { type, checker } = getTypes(code);
+    const { checker, type } = getTypes(code);
     const result = getTypeName(checker, type);
     expect(result).toBe(expected);
   }