@typescript-eslint/eslint-plugin 8.25.1-alpha.1 → 8.25.1-alpha.10

package/dist/rules/no-invalid-void-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-invalid-void-type.d.ts","sourceRoot":"","sources":["../../src/rules/no-invalid-void-type.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,OAAO;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,2BAA2B,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;CAC/D;AAED,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,sBAAsB,GACtB,+BAA+B,GAC/B,iCAAiC,GACjC,0CAA0C,GAC1C,6BAA6B,CAAC;;AAElC,wBA0OG"}
+{"version":3,"file":"no-invalid-void-type.d.ts","sourceRoot":"","sources":["../../src/rules/no-invalid-void-type.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,OAAO;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,2BAA2B,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;CAC/D;AAED,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,sBAAsB,GACtB,+BAA+B,GAC/B,iCAAiC,GACjC,0CAA0C,GAC1C,6BAA6B,CAAC;;AAElC,wBA2OG"}

package/dist/rules/no-invalid-void-type.js

@@ -57,6 +57,7 @@ exports.default = (0, util_1.createRule)({
             utils_1.AST_NODE_TYPES.TSPropertySignature,
             utils_1.AST_NODE_TYPES.CallExpression,
             utils_1.AST_NODE_TYPES.PropertyDefinition,
+            utils_1.AST_NODE_TYPES.AccessorProperty,
             utils_1.AST_NODE_TYPES.Identifier,
         ];
         const validUnionMembers = [

package/dist/rules/no-unnecessary-type-parameters.js

@@ -185,7 +185,12 @@ function isTypeParameterRepeatedInAST(node, references, startOfBody = Infinity)
         if (reference.identifier.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
             const grandparent = skipConstituentsUpward(reference.identifier.parent.parent);
             if (grandparent.type === utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation &&
-                grandparent.params.includes(reference.identifier.parent)) {
+                grandparent.params.includes(reference.identifier.parent) &&
+                // Array and ReadonlyArray must be handled carefully
+                // let's defer the check to the type-aware phase
+                !(grandparent.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    grandparent.parent.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    ['Array', 'ReadonlyArray'].includes(grandparent.parent.typeName.name))) {
                 return true;
             }
         }
@@ -215,14 +220,14 @@ function countTypeParameterUsage(checker, node) {
     const counts = new Map();
     if (ts.isClassLike(node)) {
         for (const typeParameter of node.typeParameters) {
-            collectTypeParameterUsageCounts(checker, typeParameter, counts);
+            collectTypeParameterUsageCounts(checker, typeParameter, counts, true);
         }
         for (const member of node.members) {
-            collectTypeParameterUsageCounts(checker, member, counts);
+            collectTypeParameterUsageCounts(checker, member, counts, true);
         }
     }
     else {
-        collectTypeParameterUsageCounts(checker, node, counts);
+        collectTypeParameterUsageCounts(checker, node, counts, false);
     }
     return counts;
 }
@@ -231,7 +236,7 @@ function countTypeParameterUsage(checker, node) {
  * appears in the given type by checking its uses through its type references.
  * This is essentially a limited subset of the scope manager, but for types.
  */
-function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages) {
+function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages, fromClass) {
     const visitedSymbolLists = new Set();
     const type = checker.getTypeAtLocation(node);
     const typeUsages = new Map();
@@ -246,7 +251,7 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages) {
     if (!functionLikeType) {
         visitType(type, false);
     }
-    function visitType(type, assumeMultipleUses) {
+    function visitType(type, assumeMultipleUses, isReturnType = false) {
         // Seeing the same type > (threshold=3 ** 2) times indicates a likely
         // recursive type, like `type T = { [P in keyof T]: T }`.
         // If it's not recursive, then heck, we've seen it enough times that any
@@ -288,9 +293,21 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages) {
         }
         // Tuple types like `[K, V]`
         // Generic type references like `Map<K, V>`
-        else if (tsutils.isTupleType(type) || tsutils.isTypeReference(type)) {
+        else if (tsutils.isTypeReference(type)) {
             for (const typeArgument of type.typeArguments ?? []) {
-                visitType(typeArgument, true);
+                // currently, if we are in a "class context", everything is accepted
+                let thisAssumeMultipleUses = fromClass || assumeMultipleUses;
+                // special cases - readonly arrays/tuples are considered only to use the
+                // type parameter once. Mutable arrays/tuples are considered to use the
+                // type parameter multiple times if and only if they are returned.
+                // other kind of type references always count as multiple uses
+                thisAssumeMultipleUses ||= tsutils.isTupleType(type.target)
+                    ? isReturnType && !type.target.readonly
+                    : checker.isArrayType(type.target)
+                        ? isReturnType &&
+                            type.symbol?.getName() === 'Array'
+                        : true;
+                visitType(typeArgument, thisAssumeMultipleUses, isReturnType);
             }
         }
         // Template literals like `a${T}b`
@@ -359,7 +376,7 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages) {
             visitType(typeParameter, false);
         }
         visitType(checker.getTypePredicateOfSignature(signature)?.type ??
-            signature.getReturnType(), false);
+            signature.getReturnType(), false, true);
     }
     function visitSymbolsListOnce(symbols, assumeMultipleUses) {
         if (visitedSymbolLists.has(symbols)) {

package/dist/rules/unified-signatures.js

@@ -383,7 +383,13 @@ function getOverloadInfo(node) {
             return '()';
         default: {
             const { key } = node;
-            return isIdentifier(key) ? key.name : key.raw;
+            if (isPrivateIdentifier(key)) {
+                return `private_identifier_${key.name}`;
+            }
+            if (isIdentifier(key)) {
+                return `identifier_${key.name}`;
+            }
+            return key.raw;
         }
     }
 }
@@ -400,6 +406,9 @@ function getStaticParameterName(param) {
 function isIdentifier(node) {
     return node.type === utils_1.AST_NODE_TYPES.Identifier;
 }
+function isPrivateIdentifier(node) {
+    return node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier;
+}
 function isGetterOrSetter(node) {
     return node.kind === 'get' || node.kind === 'set';
 }

package/docs/rules/no-unnecessary-type-parameters.mdx

@@ -82,10 +82,30 @@ For example, the following `T` is used multiple times by virtue of being in an `
 declare function createStateHistory<T>(): T[];
 ```
 
-This is because the type parameter `T` relates multiple methods in the `T[]` together, making it used more than once.
+This is because the type parameter `T` relates multiple methods in `T[]` (`Array<T>`) together, making it used more than once.
 
 Therefore, this rule won't report on type parameters used as a type argument.
-That includes type arguments given to global types such as `Array` (including the `T[]` shorthand and in tuples), `Map`, and `Set`.
+This includes type arguments provided to global types such as `Array`, `Map`, and `Set` that have multiple methods and properties that can change values based on the type parameter.
+
+On the other hand, readonly and fixed array-likes such as `readonly T[]`, `ReadonlyArray`, and tuples such as `[T]` are special cases that are specifically reported on when used as input types, or as `readonly` output types.
+The following example will be reported because `T` is used only once as type argument for the `ReadonlyArray` global type:
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+declare function length<T>(array: ReadonlyArray<T>): number;
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+declare function length(array: ReadonlyArray<unknown>): number;
+```
+
+</TabItem>
+</Tabs>
 
 ## FAQ
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.25.1-alpha.1",
+  "version": "8.25.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -56,16 +56,16 @@
     "generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
     "generate:configs": "npx nx generate-configs repo",
     "lint": "npx nx lint",
-    "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage --logHeapUsage",
+    "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --logHeapUsage",
     "test-single": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --no-coverage",
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.25.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.25.1-alpha.1",
-    "@typescript-eslint/utils": "8.25.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.25.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.25.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.25.1-alpha.10",
+    "@typescript-eslint/utils": "8.25.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.25.1-alpha.10",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
@@ -76,8 +76,8 @@
     "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.25.1-alpha.1",
-    "@typescript-eslint/rule-tester": "8.25.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.25.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.25.1-alpha.10",
     "ajv": "^6.12.6",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",