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

package/dist/rules/no-misused-promises.js

@@ -337,8 +337,9 @@ exports.default = (0, util_1.createRule)({
             }
         }
         function checkArguments(node) {
-            if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                isPromiseFinallyMethod(node)) {
+            if (node.arguments.length === 0 ||
+                (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isPromiseFinallyMethod(node))) {
                 return;
             }
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);

package/dist/rules/no-unsafe-enum-assignment.js

@@ -147,7 +147,7 @@ exports.default = (0, util_1.createRule)({
             }
         }
         function isUnsafeAssignment(senderNode, receiverType, senderType = services.getTypeAtLocation(senderNode)) {
-            return (hasDeepEnumAssignmentMismatch(checker, senderType, receiverType) &&
+            return (hasEnumAssignmentMismatch(checker, senderType, receiverType) &&
                 !isSafeEnumBitwiseExpression(senderNode, receiverType));
         }
         function checkAssignment(receiverType, senderNode, reportingNode, messageId = 'unsafeEnumAssignment', senderType) {
@@ -181,7 +181,7 @@ exports.default = (0, util_1.createRule)({
                             .flatMap(elementType => {
                             const parameterType = signature.getNextParameterType();
                             return parameterType != null &&
-                                hasDeepEnumAssignmentMismatch(checker, elementType, parameterType)
+                                hasEnumAssignmentMismatch(checker, elementType, parameterType)
                                 ? [parameterType]
                                 : [];
                         });
@@ -311,7 +311,8 @@ exports.default = (0, util_1.createRule)({
                 // declare const foo: { [key in Fruit]: string };
                 // foo[0];
                 const senderType = services.getTypeAtLocation(node.property);
-                if (receiverTypes.every(receiverType => hasDeepEnumAssignmentMismatch(checker, senderType, receiverType) || !checker.isTypeAssignableTo(senderType, receiverType))) {
+                if (receiverTypes.every(receiverType => hasEnumAssignmentMismatch(checker, senderType, receiverType) ||
+                    !checker.isTypeAssignableTo(senderType, receiverType))) {
                     report(node.property, 'unsafeEnumAccess', receiverTypes);
                 }
             },
@@ -355,9 +356,46 @@ function getConstraintType(checker, type) {
 function getTypeArguments(checker, type) {
     return tsutils.isTypeReference(type) ? checker.getTypeArguments(type) : [];
 }
-function hasDeepEnumAssignmentMismatch(checker, senderType, receiverType, visited = new WeakMap()) {
+const genericTypes = new WeakMap();
+function isGenericType(checker, type) {
+    let generic = genericTypes.get(type);
+    if (generic == null) {
+        genericTypes.set(type, false);
+        generic =
+            tsutils.isTypeFlagSet(type, ts.TypeFlags.Instantiable) ||
+                [
+                    ...(tsutils.isUnionOrIntersectionType(type) ? type.types : []),
+                    ...(type.aliasTypeArguments ?? []),
+                    ...getTypeArguments(checker, type),
+                ].some(part => isGenericType(checker, part));
+        genericTypes.set(type, generic);
+    }
+    return generic;
+}
+const maximumDepth = 5;
+const topLevelMismatches = new WeakMap();
+function hasEnumAssignmentMismatch(checker, senderType, receiverType) {
+    let receiverMismatches = topLevelMismatches.get(senderType);
+    if (receiverMismatches == null) {
+        receiverMismatches = new WeakMap();
+        topLevelMismatches.set(senderType, receiverMismatches);
+    }
+    let mismatch = receiverMismatches.get(receiverType);
+    if (mismatch == null) {
+        mismatch = hasDeepEnumAssignmentMismatch(checker, senderType, receiverType);
+        receiverMismatches.set(receiverType, mismatch);
+    }
+    return mismatch;
+}
+function hasDeepEnumAssignmentMismatch(checker, senderType, receiverType, visited = new WeakMap(), depth = 0, withinGenericMembers = false) {
+    if (depth > maximumDepth) {
+        return false;
+    }
     const constrainedSenderType = getConstraintType(checker, senderType);
     const constrainedReceiverType = getConstraintType(checker, receiverType);
+    if (constrainedSenderType === constrainedReceiverType) {
+        return false;
+    }
     // Recursive types would otherwise be visited endlessly.
     let visitedReceiverTypes = visited.get(constrainedSenderType);
     if (visitedReceiverTypes == null) {
@@ -375,22 +413,28 @@ function hasDeepEnumAssignmentMismatch(checker, senderType, receiverType, visite
     const senderTypeArguments = getTypeArguments(checker, constrainedSenderType);
     const receiverTypeArguments = getTypeArguments(checker, constrainedReceiverType);
     if (senderTypeArguments.length === receiverTypeArguments.length &&
-        senderTypeArguments.some((senderTypeArgument, index) => hasDeepEnumAssignmentMismatch(checker, senderTypeArgument, receiverTypeArguments[index], visited))) {
+        senderTypeArguments.some((senderTypeArgument, index) => hasDeepEnumAssignmentMismatch(checker, senderTypeArgument, receiverTypeArguments[index], visited, depth + 1, withinGenericMembers))) {
         return true;
     }
+    // Members of generic types can instantiate ever-larger generic types.
+    const generic = isGenericType(checker, constrainedSenderType) ||
+        isGenericType(checker, constrainedReceiverType);
+    if (generic && withinGenericMembers) {
+        return false;
+    }
     // [number, Fruit] -> Fruit[]
     const senderElementType = constrainedSenderType.getNumberIndexType();
     const receiverElementType = constrainedReceiverType.getNumberIndexType();
     if (senderElementType &&
         receiverElementType &&
-        hasDeepEnumAssignmentMismatch(checker, senderElementType, receiverElementType, visited)) {
+        hasDeepEnumAssignmentMismatch(checker, senderElementType, receiverElementType, visited, depth + 1, generic || withinGenericMembers)) {
         return true;
     }
     // { fruit: number } -> { fruit: Fruit }
     return constrainedReceiverType.getProperties().some(receiverProperty => {
         const senderProperty = constrainedSenderType.getProperty(receiverProperty.name);
         return (senderProperty != null &&
-            hasDeepEnumAssignmentMismatch(checker, checker.getTypeOfSymbol(senderProperty), checker.getTypeOfSymbol(receiverProperty), visited));
+            hasDeepEnumAssignmentMismatch(checker, checker.getTypeOfSymbol(senderProperty), checker.getTypeOfSymbol(receiverProperty), visited, depth + 1, generic || withinGenericMembers));
     });
 }
 function getMappedKeyConstraintTypes(checker, declaration) {

package/dist/rules/no-unused-vars.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const scope_manager_1 = require("@typescript-eslint/scope-manager");
 const utils_1 = require("@typescript-eslint/utils");
 const util_1 = require("../util");
-const referenceContainsTypePredicate_1 = require("../util/referenceContainsTypePredicate");
-const referenceContainsTypeQuery_1 = require("../util/referenceContainsTypeQuery");
+const isTypeOnlyReference_1 = require("../util/isTypeOnlyReference");
 // this is a superset of DefinitionType which defines sub-types for better granularity
 var VariableType;
 (function (VariableType) {
@@ -821,8 +820,7 @@ exports.default = (0, util_1.createRule)({
                 for (const unusedVar of unusedVars) {
                     // Report the first declaration.
                     if (unusedVar.defs.length > 0) {
-                        const usedOnlyAsType = unusedVar.references.some(ref => (0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier) ||
-                            (0, referenceContainsTypePredicate_1.referenceContainsTypePredicate)(ref.identifier));
+                        const usedOnlyAsType = unusedVar.references.some(ref => (0, isTypeOnlyReference_1.isTypeOnlyReference)(unusedVar, ref));
                         const messageId = usedOnlyAsType ? 'usedOnlyAsType' : 'unusedVar';
                         const isImportUsedOnlyAsType = usedOnlyAsType &&
                             unusedVar.defs.some(def => def.type === scope_manager_1.DefinitionType.ImportBinding);

package/dist/rules/require-array-sort-compare.js

@@ -40,7 +40,10 @@ exports.default = (0, util_1.createRule)({
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             if (checker.isArrayType(type) || checker.isTupleType(type)) {
                 const typeArgs = checker.getTypeArguments(type);
-                return typeArgs.every(arg => (0, util_1.getTypeName)(checker, arg) === 'string');
+                return typeArgs.every(arg => {
+                    const typeName = (0, util_1.getTypeName)(checker, checker.getBaseConstraintOfType(arg) ?? arg);
+                    return typeName === 'string';
+                });
             }
             return false;
         }

package/dist/util/collectUnusedVariables.js

@@ -4,8 +4,7 @@ exports.collectVariables = collectVariables;
 const scope_manager_1 = require("@typescript-eslint/scope-manager");
 const utils_1 = require("@typescript-eslint/utils");
 const isTypeImport_1 = require("./isTypeImport");
-const referenceContainsTypePredicate_1 = require("./referenceContainsTypePredicate");
-const referenceContainsTypeQuery_1 = require("./referenceContainsTypeQuery");
+const isTypeOnlyReference_1 = require("./isTypeOnlyReference");
 /**
  * This class leverages an AST visitor to mark variables as used via the
  * `eslintUsed` property.
@@ -289,6 +288,11 @@ const MERGEABLE_TYPES = new Set([
     utils_1.AST_NODE_TYPES.TSModuleDeclaration,
     utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration,
 ]);
+function isMergedTypeDeclaration(variable, node) {
+    return ((node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) &&
+        (0, isTypeOnlyReference_1.isMergedTypeValueVariable)(variable));
+}
 /**
  * Determine if the variable is directly exported
  * @param variable the variable to check
@@ -305,7 +309,7 @@ function isMergeableExported(variable) {
         if ((MERGEABLE_TYPES.has(def.node.type) &&
             def.node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) ||
             def.node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
-            return true;
+            return !isMergedTypeDeclaration(variable, def.node);
         }
     }
     return false;
@@ -324,7 +328,8 @@ function isExported(variable) {
         else if (definition.type === utils_1.TSESLint.Scope.DefinitionType.Parameter) {
             return false;
         }
-        return node.parent.type.startsWith('Export');
+        return (!isMergedTypeDeclaration(variable, node) &&
+            node.parent.type.startsWith('Export'));
     });
 }
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(['??=', '&&=', '||=']);
@@ -579,9 +584,7 @@ function isUsedVariable(variable) {
         rhsNode = getRhsNode(ref, rhsNode);
         return (ref.isRead() &&
             !forItself &&
-            !(!isImportedAsType &&
-                ((0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier) ||
-                    (0, referenceContainsTypePredicate_1.referenceContainsTypePredicate)(ref.identifier))) &&
+            !(!isImportedAsType && (0, isTypeOnlyReference_1.isTypeOnlyReference)(variable, ref)) &&
             !(isFunctionDefinition && isSelfReference(ref, functionNodes)) &&
             !(isTypeDecl && isInsideOneOf(ref, typeDeclNodes)) &&
             !(isModuleDecl && isSelfReference(ref, moduleDeclNodes)) &&

package/dist/util/isTypeOnlyReference.d.ts

@@ -0,0 +1,4 @@
+import type { ScopeVariable } from '@typescript-eslint/scope-manager';
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare function isMergedTypeValueVariable(variable: ScopeVariable): boolean;
+export declare function isTypeOnlyReference(variable: ScopeVariable, ref: TSESLint.Scope.Reference): boolean;

package/dist/util/isTypeOnlyReference.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMergedTypeValueVariable = isMergedTypeValueVariable;
+exports.isTypeOnlyReference = isTypeOnlyReference;
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const referenceContainsTypePredicate_1 = require("./referenceContainsTypePredicate");
+const referenceContainsTypeQuery_1 = require("./referenceContainsTypeQuery");
+function isMergedTypeValueVariable(variable) {
+    return ('isTypeVariable' in variable &&
+        'isValueVariable' in variable &&
+        variable.isTypeVariable &&
+        variable.isValueVariable);
+}
+function isTypeOnlyReference(variable, ref) {
+    if ((0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier) ||
+        (0, referenceContainsTypePredicate_1.referenceContainsTypePredicate)(ref.identifier)) {
+        return true;
+    }
+    return (variable.defs.some(def => def.type === scope_manager_1.DefinitionType.Variable) &&
+        !ref.isValueReference);
+}
+//# sourceMappingURL=isTypeOnlyReference.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.71.1-alpha.1",
+  "version": "8.71.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -47,10 +47,10 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.71.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.71.1-alpha.1",
-    "@typescript-eslint/utils": "8.71.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.71.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.71.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.71.1-alpha.10",
+    "@typescript-eslint/utils": "8.71.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.71.1-alpha.10",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
@@ -60,8 +60,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.71.1-alpha.1",
-    "@typescript-eslint/rule-tester": "8.71.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.71.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.71.1-alpha.10",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -81,7 +81,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.71.1-alpha.1",
+    "@typescript-eslint/parser": "^8.71.1-alpha.10",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },