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

package/dist/rules/ban-ts-comment.js

@@ -121,7 +121,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 return execDirectiveRegEx(commentDirectiveRegExSingleLine, comment.value);
             }
-            const commentLines = comment.value.split('\n');
+            const commentLines = comment.value.split(utils_1.ASTUtils.LINEBREAK_MATCHER);
             return execDirectiveRegEx(commentDirectiveRegExMultiLine, commentLines[commentLines.length - 1]);
         }
         return {

package/dist/rules/naming-convention.js

@@ -457,6 +457,7 @@ exports.default = (0, util_1.createRule)({
             return [
                 selector,
                 (node) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                     handler(node, validator);
                 },
             ];

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-shadow.js

@@ -322,29 +322,59 @@ exports.default = (0, util_1.createRule)({
             return false;
         }
         /**
-         * Checks if a variable is inside the initializer of scopeVar.
+         * Finds the uppermost expression node that can evaluate to the given one,
+         * unwrapping through LogicalExpression and non-test ConditionalExpression branches.
+         * @param node The node to unwrap.
+         * @returns The topmost unwrapped node.
+         */
+        function unwrapExpression(node) {
+            const { parent } = node;
+            if (parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                (parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                    parent.test !== node)) {
+                return unwrapExpression(parent);
+            }
+            return node;
+        }
+        /**
+         * Checks if a variable is the name of a function or class expression that is
+         * directly assigned (or transparently through `||`/`?:`) as the initializer
+         * of scopeVar.
          *
-         * To avoid reporting at declarations such as `var a = function a() {};`.
-         * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
+         * Allows `var a = function a() {}` but reports `var a = wrap(function a() {})`.
          * @param variable The variable to check.
          * @param scopeVar The scope variable to look for.
-         * @returns Whether or not the variable is inside initializer of scopeVar.
+         * @returns Whether or not the variable is the direct initializer name of scopeVar.
          */
         function isOnInitializer(variable, scopeVar) {
-            const outerScope = scopeVar.scope;
             const outerDef = scopeVar.defs.at(0);
-            const outer = outerDef?.parent?.range;
-            const innerScope = variable.scope;
             const innerDef = variable.defs.at(0);
-            const inner = innerDef?.name.range;
-            return !!(outer &&
-                inner &&
-                outer[0] < inner[0] &&
-                inner[1] < outer[1] &&
-                ((innerDef.type === scope_manager_1.DefinitionType.FunctionName &&
-                    innerDef.node.type === utils_1.AST_NODE_TYPES.FunctionExpression) ||
-                    innerDef.node.type === utils_1.AST_NODE_TYPES.ClassExpression) &&
-                outerScope === innerScope.upper);
+            if (!outerDef || !innerDef) {
+                return false;
+            }
+            if (!((innerDef.type === scope_manager_1.DefinitionType.FunctionName &&
+                innerDef.node.type === utils_1.AST_NODE_TYPES.FunctionExpression) ||
+                (innerDef.type === scope_manager_1.DefinitionType.ClassName &&
+                    innerDef.node.type === utils_1.AST_NODE_TYPES.ClassExpression))) {
+                return false;
+            }
+            const outerIdentifier = outerDef.name;
+            let initializerNode;
+            if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                initializerNode = outerIdentifier.parent.init;
+            }
+            else if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                initializerNode = outerIdentifier.parent.right;
+            }
+            if (!initializerNode) {
+                return false;
+            }
+            const nodeToCheck = innerDef.node;
+            if (!(initializerNode.range[0] <= nodeToCheck.range[0] &&
+                nodeToCheck.range[1] <= initializerNode.range[1])) {
+                return false;
+            }
+            return initializerNode === unwrapExpression(nodeToCheck);
         }
         /**
          * Get a range of a variable's identifier node.

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/prefer-ts-expect-error.js

@@ -40,7 +40,7 @@ exports.default = (0, util_1.createRule)({
                 return comment.value;
             }
             // For multiline comments - we look at only the last line.
-            const commentlines = comment.value.split('\n');
+            const commentlines = comment.value.split(utils_1.ASTUtils.LINEBREAK_MATCHER);
             return commentlines[commentlines.length - 1];
         }
         function isValidTsIgnorePresent(comment) {

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.1",
+  "version": "8.60.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -52,16 +52,17 @@
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0",
-    "@typescript-eslint/scope-manager": "8.60.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.60.1-alpha.1",
-    "@typescript-eslint/utils": "8.60.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.60.1-alpha.1"
+    "@typescript-eslint/scope-manager": "8.60.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.60.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.60.1-alpha.10",
+    "@typescript-eslint/utils": "8.60.1-alpha.10"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
+    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
     "eslint": "^10.0.0",
@@ -78,13 +79,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.1",
-    "@typescript-eslint/rule-tester": "8.60.1-alpha.1"
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.60.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.60.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.60.1-alpha.1"
+    "@typescript-eslint/parser": "^8.60.1-alpha.10"
   },
   "funding": {
     "type": "opencollective",
@@ -107,7 +108,8 @@
       },
       "lint": {
         "command": "eslint"
-      }
+      },
+      "typecheck:tsgo": {}
     }
   },
   "scripts": {
@@ -118,6 +120,7 @@
     "generate-configs": "pnpm -w run generate-configs",
     "lint": "pnpm -w exec nx lint",
     "test": "pnpm -w exec nx test",
-    "typecheck": "pnpm -w exec nx typecheck"
+    "typecheck": "pnpm -w exec nx typecheck",
+    "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo"
   }
 }