@typescript-eslint/eslint-plugin 8.60.1-alpha.2 → 8.60.1-alpha.4

package/dist/rules/no-base-to-string.js

@@ -289,8 +289,8 @@ exports.default = (0, util_1.createRule)({
                 if ((0, util_1.getTypeName)(checker, leftType) === 'string') {
                     checkExpression(node.right, rightType);
                 }
-                else if ((0, util_1.getTypeName)(checker, rightType) === 'string' &&
-                    node.left.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                else if (node.left.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier &&
+                    (0, util_1.getTypeName)(checker, rightType) === 'string') {
                     checkExpression(node.left, leftType);
                 }
             },

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

@@ -99,16 +99,16 @@ exports.default = (0, util_1.createRule)({
         const services = (0, util_1.getParserServices)(context);
         return {
             'AwaitExpression, CallExpression, TaggedTemplateExpression'(node) {
-                const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
-                if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
-                    // not a void expression
-                    return;
-                }
                 const invalidAncestor = findInvalidAncestor(node);
                 if (invalidAncestor == null) {
                     // void expression is in valid position
                     return;
                 }
+                const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+                if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
+                    // not a void expression
+                    return;
+                }
                 const wrapVoidFix = (fixer) => {
                     const nodeText = context.sourceCode.getText(node);
                     const newNodeText = `void ${nodeText}`;

package/dist/rules/no-duplicate-type-constituents.js

@@ -148,17 +148,25 @@ exports.default = (0, util_1.createRule)({
             });
         }
         function checkDuplicateRecursively(unionOrIntersection, constituentNode, uniqueConstituents, cachedTypeMap, forEachNodeType) {
+            const reportDuplicate = (previous) => {
+                report('duplicate', constituentNode, {
+                    type: unionOrIntersection,
+                    previous: sourceCode.getText(previous),
+                });
+            };
+            // Check duplicates in the AST before type lookup for better performance.
+            let duplicatedPrevious = uniqueConstituents.find(ele => isSameAstNode(ele, constituentNode));
+            if (duplicatedPrevious) {
+                reportDuplicate(duplicatedPrevious);
+                return;
+            }
             const type = parserServices.getTypeAtLocation(constituentNode);
             if (tsutils.isIntrinsicErrorType(type)) {
                 return;
             }
-            const duplicatedPrevious = uniqueConstituents.find(ele => isSameAstNode(ele, constituentNode)) ??
-                cachedTypeMap.get(type);
+            duplicatedPrevious = cachedTypeMap.get(type);
             if (duplicatedPrevious) {
-                report('duplicate', constituentNode, {
-                    type: unionOrIntersection,
-                    previous: sourceCode.getText(duplicatedPrevious),
-                });
+                reportDuplicate(duplicatedPrevious);
                 return;
             }
             forEachNodeType?.(type, constituentNode);

package/dist/rules/no-unsafe-return.js

@@ -63,13 +63,13 @@ exports.default = (0, util_1.createRule)({
         const compilerOptions = services.program.getCompilerOptions();
         const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
         function checkReturn(returnNode, reportingNode = returnNode) {
-            const tsNode = services.esTreeNodeToTSNodeMap.get(returnNode);
-            const type = checker.getTypeAtLocation(tsNode);
-            const anyType = (0, util_1.discriminateAnyType)(type, checker, services.program, tsNode);
             const functionNode = (0, getParentFunctionNode_1.getParentFunctionNode)(returnNode);
             /* istanbul ignore if */ if (!functionNode) {
                 return;
             }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(returnNode);
+            const type = checker.getTypeAtLocation(tsNode);
+            const anyType = (0, util_1.discriminateAnyType)(type, checker, services.program, tsNode);
             // function has an explicit return type, so ensure it's a safe return
             const returnNodeType = services.getTypeAtLocation(returnNode);
             const constrainedReturnNodeType = (0, util_1.getConstrainedTypeAtLocation)(services, returnNode);

package/dist/rules/prefer-nullish-coalescing.js

@@ -216,10 +216,6 @@ exports.default = (0, util_1.createRule)({
          * @param testNode The node being tested (i.e. `a`)
          */
         function isTruthinessCheckEligibleForPreferNullish({ node, testNode, }) {
-            const testType = parserServices.getTypeAtLocation(testNode);
-            if (!isTypeEligibleForPreferNullish(testType)) {
-                return false;
-            }
             if (ignoreConditionalTests === true && isConditionalTest(node)) {
                 return false;
             }
@@ -229,6 +225,10 @@ exports.default = (0, util_1.createRule)({
                     node.parent.type === utils_1.AST_NODE_TYPES.CallExpression)) {
                 return false;
             }
+            const testType = parserServices.getTypeAtLocation(testNode);
+            if (!isTypeEligibleForPreferNullish(testType)) {
+                return false;
+            }
             return true;
         }
         function checkAndFixWithPreferNullishOverOr(node, description, equals) {

package/dist/rules/strict-void-return.js

@@ -153,6 +153,9 @@ exports.default = util.createRule({
          * and report them too.
          */
         function checkFunctionCallNode(callNode) {
+            if (callNode.arguments.length === 0) {
+                return;
+            }
             const callTsNode = parserServices.esTreeNodeToTSNodeMap.get(callNode);
             const funcType = checker.getTypeAtLocation(callTsNode.expression);
             const funcSignatures = tsutils

package/package.json

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