@typescript-eslint/eslint-plugin 8.71.1-alpha.8 → 8.71.1

package/dist/rules/no-confusing-void-expression.js

@@ -317,7 +317,27 @@ exports.default = (0, util_1.createRule)({
                 ? node.argument
                 : node.body;
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, targetNode);
-            return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
+            if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
+                return false;
+            }
+            const functionNode = (0, util_1.nullThrows)(node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression
+                ? node
+                : (0, getParentFunctionNode_1.getParentFunctionNode)(node), 'Expected a return statement to be inside a function.');
+            return functionDeclarationAllowsEmptyReturn(functionNode);
+        }
+        function functionDeclarationAllowsEmptyReturn(functionNode) {
+            if (!functionNode.returnType) {
+                return true;
+            }
+            const declaredReturnType = services.getTypeFromTypeNode(functionNode.returnType.typeAnnotation);
+            const checker = services.program.getTypeChecker();
+            const resolvedReturnType = functionNode.async
+                ? (checker.getAwaitedType(declaredReturnType) ?? declaredReturnType)
+                : declaredReturnType;
+            return tsutils
+                .unionConstituents(resolvedReturnType)
+                .some(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Any) ||
+                tsutils.isTypeFlagSet(part, ts.TypeFlags.VoidLike));
         }
         function isFunctionReturnTypeIncludesVoid(functionType) {
             const callSignatures = tsutils.getCallSignaturesOfType(functionType);

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

@@ -353,9 +353,24 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages, f
                     // TS treats mapped types like `{[k in "a"]: T}` like `{a: T}`.
                     // They have properties, so we need to avoid double-counting.
                     visitType(type.templateType ?? type.constraintType, false);
+                    // `templateType` is a lazily populated checker cache. Once it is
+                    // populated on an instantiated mapped type, its constraint is
+                    // reachable only here: the type parameter's declaration holds the
+                    // original constraint from before instantiation.
+                    if (type.templateType &&
+                        type.constraintType &&
+                        type.constraintType !==
+                            getDeclaredConstraintType(type.typeParameter)) {
+                        visitType(type.constraintType, false);
+                    }
                 }
                 // TS doesn't count mapped types key remapping (`{[K in 'a' as T]: K}`)
                 // but handles this under `MappedType.nameType`, so we need to visit that too.
+                // Instantiated mapped types populate it lazily, which getting the
+                // awaited type forces.
+                if (!type.nameType) {
+                    checker.getAwaitedType(type);
+                }
                 if (type.nameType) {
                     visitType(type.nameType, false);
                 }
@@ -386,6 +401,13 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages, f
         typeUsages.set(type, count);
         return count;
     }
+    function getDeclaredConstraintType(typeParameter) {
+        const constraint = typeParameter
+            ?.getSymbol()
+            ?.getDeclarations()
+            ?.find(ts.isTypeParameterDeclaration)?.constraint;
+        return constraint && checker.getTypeAtLocation(constraint);
+    }
     function visitSignature(signature) {
         if (!signature) {
             return;

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/prefer-optional-chain-utils/analyzeChain.js

@@ -52,21 +52,25 @@ function includesType(parserServices, node, typeFlagIn) {
     }
     return false;
 }
+const MAYBE_UNDEFINED_FLAGS = ts.TypeFlags.Any |
+    ts.TypeFlags.Unknown |
+    ts.TypeFlags.InstantiableNonPrimitive |
+    ts.TypeFlags.Undefined |
+    ts.TypeFlags.Void;
 function isValidAndLastChainOperand(ComparisonValueType, comparisonType, parserServices) {
-    const type = parserServices.getTypeAtLocation(ComparisonValueType);
-    const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown;
+    const type = (0, util_1.getConstrainedTypeAtLocation)(parserServices, ComparisonValueType);
     const types = (0, ts_api_utils_1.unionConstituents)(type);
     switch (comparisonType) {
         case gatherLogicalOperands_1.ComparisonType.Equal: {
             const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
-            ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            MAYBE_UNDEFINED_FLAGS | ts.TypeFlags.Null));
             return !isNullish;
         }
         case gatherLogicalOperands_1.ComparisonType.StrictEqual: {
             const isUndefined = types.some(t => 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
-            (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            (0, util_1.isTypeFlagSet)(t, MAYBE_UNDEFINED_FLAGS));
             return !isUndefined;
         }
         case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
@@ -78,20 +82,19 @@ function isValidAndLastChainOperand(ComparisonValueType, comparisonType, parserS
     }
 }
 function isValidOrLastChainOperand(ComparisonValueType, comparisonType, parserServices) {
-    const type = parserServices.getTypeAtLocation(ComparisonValueType);
-    const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown;
+    const type = (0, util_1.getConstrainedTypeAtLocation)(parserServices, ComparisonValueType);
     const types = (0, ts_api_utils_1.unionConstituents)(type);
     switch (comparisonType) {
         case gatherLogicalOperands_1.ComparisonType.NotEqual: {
             const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
-            ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            MAYBE_UNDEFINED_FLAGS | ts.TypeFlags.Null));
             return !isNullish;
         }
         case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
             const isUndefined = types.some(t => 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-assignment
-            (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            (0, util_1.isTypeFlagSet)(t, MAYBE_UNDEFINED_FLAGS));
             return !isUndefined;
         }
         case gatherLogicalOperands_1.ComparisonType.Equal:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.71.1-alpha.8",
+  "version": "8.71.1",
   "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.8",
-    "@typescript-eslint/type-utils": "8.71.1-alpha.8",
-    "@typescript-eslint/utils": "8.71.1-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.71.1-alpha.8",
+    "@typescript-eslint/scope-manager": "8.71.1",
+    "@typescript-eslint/type-utils": "8.71.1",
+    "@typescript-eslint/utils": "8.71.1",
+    "@typescript-eslint/visitor-keys": "8.71.1",
     "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.8",
-    "@typescript-eslint/rule-tester": "8.71.1-alpha.8",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.71.1",
+    "@typescript-eslint/rule-tester": "8.71.1",
     "@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.8",
+    "@typescript-eslint/parser": "^8.71.1",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },