@typescript-eslint/eslint-plugin 8.59.1-alpha.0 → 8.59.1-alpha.10

package/dist/rules/no-unnecessary-condition.js

@@ -51,7 +51,9 @@ function isAlwaysNullish(type) {
  * `any` or `unknown` to be nullable.
  */
 function isPossiblyNullish(type) {
-    return tsutils.unionConstituents(type).some(isNullishType);
+    return tsutils
+        .unionConstituents(type)
+        .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
 }
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.

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

@@ -106,6 +106,11 @@ exports.default = (0, util_1.createRule)({
         }
         return {
             TSTypeParameterInstantiation(node) {
+                // TypeScript does not apply default type parameters in instantiation
+                // expressions, so explicit type args here are always meaningful.
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSInstantiationExpression) {
+                    return;
+                }
                 const expression = services.esTreeNodeToTSNodeMap.get(node);
                 const typeParameters = getTypeParametersFromNode(node, expression, checker);
                 if (typeParameters) {

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

@@ -218,7 +218,13 @@ exports.default = (0, util_1.createRule)({
             return type.isLiteral() || tsutils.isBooleanLiteralType(type);
         }
         function hasIndexSignature(type) {
-            return checker.getIndexInfosOfType(type).length > 0;
+            return tsutils
+                .unionConstituents(type)
+                .some(part => checker.getIndexInfosOfType(part).length > 0);
+        }
+        function getTypeArguments(type) {
+            return (type.aliasTypeArguments ??
+                (tsutils.isTypeReference(type) ? checker.getTypeArguments(type) : []));
         }
         function typeContains(type, predicate, seen = new Set()) {
             if (seen.has(type)) {
@@ -232,7 +238,7 @@ exports.default = (0, util_1.createRule)({
                 return type.types.some(t => typeContains(t, predicate, seen));
             }
             const nestedTypes = [
-                ...checker.getTypeArguments(type),
+                ...getTypeArguments(type),
                 ...type
                     .getCallSignatures()
                     .flatMap(sig => [
@@ -248,6 +254,9 @@ exports.default = (0, util_1.createRule)({
         function containsTypeVariable(type) {
             return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.TypeVariable | ts.TypeFlags.Index));
         }
+        function hasPhantomTypeArguments(type) {
+            return isEmptyObjectType(type) && getTypeArguments(type).length > 0;
+        }
         function hasTypeParams(sig) {
             return (sig.getTypeParameters()?.length ?? 0) > 0;
         }
@@ -281,8 +290,8 @@ exports.default = (0, util_1.createRule)({
             });
         }
         function haveSameTypeArguments(uncast, cast) {
-            const uncastArgs = checker.getTypeArguments(uncast);
-            const castArgs = checker.getTypeArguments(cast);
+            const uncastArgs = getTypeArguments(uncast);
+            const castArgs = getTypeArguments(cast);
             return (uncastArgs.length === castArgs.length &&
                 uncastArgs.every((arg, i) => arg === castArgs[i]));
         }
@@ -385,7 +394,7 @@ exports.default = (0, util_1.createRule)({
                 if (param.valueDeclaration &&
                     ts.isParameter(param.valueDeclaration) &&
                     param.valueDeclaration.dotDotDotToken) {
-                    const typeArgs = checker.getTypeArguments(paramType);
+                    const typeArgs = getTypeArguments(paramType);
                     if (typeArgs.length > 0) {
                         paramType = typeArgs[0];
                     }
@@ -447,6 +456,14 @@ exports.default = (0, util_1.createRule)({
             const assignmentParent = parent.parent;
             return assignmentParent.type !== utils_1.AST_NODE_TYPES.ExpressionStatement;
         }
+        function isRightHandSideOfLogicalAssignment(node) {
+            const { parent } = node;
+            return (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                parent.right === node &&
+                (parent.operator === '&&=' ||
+                    parent.operator === '||=' ||
+                    parent.operator === '??='));
+        }
         function isInGenericContext(node) {
             let seenFunction = false;
             for (let current = node.parent; current; current = current.parent) {
@@ -481,6 +498,12 @@ exports.default = (0, util_1.createRule)({
             }
             return false;
         }
+        function hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) {
+            return (isInGenericContext(node) &&
+                (hasPhantomTypeArguments(uncastType) ||
+                    hasPhantomTypeArguments(contextualType)) &&
+                !haveSameTypeArguments(uncastType, contextualType));
+        }
         const SKIP_PARENT_TYPES = new Set([
             utils_1.AST_NODE_TYPES.TSAsExpression,
             utils_1.AST_NODE_TYPES.TSTypeAssertion,
@@ -497,6 +520,7 @@ exports.default = (0, util_1.createRule)({
                 isInDestructuringDeclaration(node) ||
                 isPropertyInProblematicContext(node) ||
                 isAssignmentInNonStatementContext(node) ||
+                isRightHandSideOfLogicalAssignment(node) ||
                 isArgumentToOverloadedFunction(node)) {
                 return true;
             }
@@ -612,6 +636,7 @@ exports.default = (0, util_1.createRule)({
                     const isContextuallyUnnecessary = !typeAnnotationIsConstAssertion &&
                         !containsAny(uncastType) &&
                         anyInvolvedInContextualCheck &&
+                        !hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) &&
                         (castIsAny || !genericsMismatch(uncastType, contextualType)) &&
                         (contextualTypeIsAny ||
                             checker.isTypeAssignableTo(uncastType, contextualType)) &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.59.1-alpha.0",
+  "version": "8.59.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -52,10 +52,10 @@
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0",
-    "@typescript-eslint/scope-manager": "8.59.1-alpha.0",
-    "@typescript-eslint/utils": "8.59.1-alpha.0",
-    "@typescript-eslint/type-utils": "8.59.1-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.59.1-alpha.0"
+    "@typescript-eslint/scope-manager": "8.59.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.59.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.59.1-alpha.10",
+    "@typescript-eslint/utils": "8.59.1-alpha.10"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
@@ -78,13 +78,13 @@
     "typescript": ">=4.8.4 <6.1.0",
     "unist-util-visit": "^5.0.0",
     "vitest": "^4.0.18",
-    "@typescript-eslint/rule-tester": "8.59.1-alpha.0",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.59.1-alpha.0"
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.59.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.59.1-alpha.10"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0",
-    "@typescript-eslint/parser": "^8.59.1-alpha.0"
+    "@typescript-eslint/parser": "^8.59.1-alpha.10"
   },
   "funding": {
     "type": "opencollective",