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

package/dist/rules/consistent-type-exports.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
 exports.default = (0, util_1.createRule)({
@@ -86,10 +87,10 @@ exports.default = (0, util_1.createRule)({
             if (symbol.getDeclarations()?.some(ts.isTypeOnlyImportOrExportDeclaration)) {
                 return true;
             }
-            if (symbol.flags & ts.SymbolFlags.Value) {
+            if (tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Value)) {
                 return false;
             }
-            return symbol.flags & ts.SymbolFlags.Alias
+            return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
                 ? isSymbolTypeBased(checker.getImmediateAliasedSymbol(symbol))
                 : true;
         }

package/dist/rules/dot-notation.js

@@ -127,7 +127,7 @@ exports.default = (0, util_1.createRule)({
                             .getTypeAtLocation(node.object)
                             .getNonNullableType();
                         const indexInfos = checker.getIndexInfosOfType(objectType);
-                        if (indexInfos.some(info => info.keyType.flags & ts.TypeFlags.StringLike)) {
+                        if (indexInfos.some(info => tsutils.isTypeFlagSet(info.keyType, ts.TypeFlags.StringLike))) {
                             return;
                         }
                     }

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

@@ -186,8 +186,8 @@ exports.default = (0, util_1.createRule)({
                 return option.checkUnknown ? Usefulness.Sometimes : Usefulness.Always;
             }
             // the Boolean type definition missing toString()
-            if (type.flags & ts.TypeFlags.Boolean ||
-                type.flags & ts.TypeFlags.BooleanLiteral) {
+            if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Boolean) ||
+                tsutils.isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral)) {
                 return Usefulness.Always;
             }
             const symbol = type.aliasSymbol ?? type.getSymbol();

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

@@ -97,7 +97,6 @@ exports.default = (0, util_1.createRule)({
     ],
     create(context, [options]) {
         const services = (0, util_1.getParserServices)(context);
-        const checker = services.program.getTypeChecker();
         return {
             'AwaitExpression, CallExpression, TaggedTemplateExpression'(node) {
                 const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
@@ -338,15 +337,14 @@ exports.default = (0, util_1.createRule)({
             //   - Otherwise, check if the function is a function-expression or an arrow-function.
             //   -   If it is, get its contextual type and bail if we cannot.
             //   - Return based on whether the contextual type includes `void` or not
-            const functionTSNode = services.esTreeNodeToTSNodeMap.get(functionNode);
-            if (functionTSNode.type) {
-                const returnType = checker.getTypeFromTypeNode(functionTSNode.type);
+            if (functionNode.returnType) {
+                const returnType = services.getTypeFromTypeNode(functionNode.returnType.typeAnnotation);
                 return tsutils
                     .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             }
-            if (ts.isExpression(functionTSNode)) {
-                const functionType = checker.getContextualType(functionTSNode);
+            if (functionNode.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                const functionType = services.getContextualType(functionNode);
                 if (functionType) {
                     return tsutils
                         .unionConstituents(functionType)

package/dist/rules/no-deprecated.js

@@ -267,8 +267,7 @@ exports.default = (0, util_1.createRule)({
             false) ?? getJsDocDeprecation(signature));
         }
         function getJSXAttributeDeprecation(openingElement, propertyName) {
-            const tsNode = services.esTreeNodeToTSNodeMap.get(openingElement.name);
-            const contextualType = (0, util_1.nullThrows)(checker.getContextualType(tsNode), 'Expected JSX opening element name to have contextualType');
+            const contextualType = (0, util_1.nullThrows)(services.getContextualType(openingElement.name), 'Expected JSX opening element name to have contextualType');
             const symbol = contextualType.getProperty(propertyName);
             return getJsDocDeprecation(symbol);
         }

package/dist/rules/no-meaningless-void-operator.js

@@ -79,7 +79,7 @@ exports.default = (0, util_1.createRule)({
                 };
                 const argType = services.getTypeAtLocation(node.argument);
                 const unionParts = tsutils.unionConstituents(argType);
-                if (unionParts.every(part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
+                if (unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
                     context.report({
                         node,
                         messageId: 'meaninglessVoidOperator',
@@ -88,8 +88,7 @@ exports.default = (0, util_1.createRule)({
                     });
                 }
                 else if (checkNever &&
-                    unionParts.every(part => part.flags &
-                        (ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never))) {
+                    unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never))) {
                     context.report({
                         node,
                         messageId: 'meaninglessVoidOperator',

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

@@ -281,8 +281,17 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const originalNode = services.esTreeNodeToTSNodeMap.get(node);
-                const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.expression);
-                if (!(0, util_1.isNullableType)(type)) {
+                const constrainedType = (0, util_1.getConstrainedTypeAtLocation)(services, node.expression);
+                const actualType = services.getTypeAtLocation(node.expression);
+                // Check both the constrained type and the actual type.
+                // If either is nullable, we should not report the assertion as unnecessary.
+                // This handles cases like generic constraints with `any` where the
+                // constrained type is `any` (nullable) but the actual type might be
+                // a type parameter that TypeScript treats nominally.
+                // See: https://github.com/typescript-eslint/typescript-eslint/issues/11559
+                const constrainedTypeIsNullable = (0, util_1.isNullableType)(constrainedType);
+                const actualTypeIsNullable = (0, util_1.isNullableType)(actualType);
+                if (!constrainedTypeIsNullable && !actualTypeIsNullable) {
                     if (node.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
                         isPossiblyUsedBeforeAssigned(node.expression)) {
                         return;
@@ -296,17 +305,25 @@ exports.default = (0, util_1.createRule)({
                 else {
                     // we know it's a nullable type
                     // so figure out if the variable is used in a place that accepts nullable types
+                    // If the constrained type differs from the actual type (e.g., when dealing
+                    // with unresolved generic type parameters), we should not report the assertion
+                    // as contextually unnecessary. TypeScript may still require the assertion
+                    // even if the constraint is nullable (like `any`).
+                    // See: https://github.com/typescript-eslint/typescript-eslint/issues/11559
+                    if (constrainedType !== actualType) {
+                        return;
+                    }
                     const contextualType = (0, util_1.getContextualType)(checker, originalNode);
                     if (contextualType) {
-                        if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Unknown) &&
+                        if ((0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Unknown) &&
                             !(0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Unknown)) {
                             return;
                         }
                         // in strict mode you can't assign null to undefined, so we have to make sure that
                         // the two types share a nullable type
-                        const typeIncludesUndefined = (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Undefined);
-                        const typeIncludesNull = (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Null);
-                        const typeIncludesVoid = (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Void);
+                        const typeIncludesUndefined = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Undefined);
+                        const typeIncludesNull = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Null);
+                        const typeIncludesVoid = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Void);
                         const contextualTypeIncludesUndefined = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Undefined);
                         const contextualTypeIncludesNull = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Null);
                         const contextualTypeIncludesVoid = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Void);

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

@@ -45,7 +45,7 @@ function isEnumMemberType(type) {
     if (!symbol) {
         return false;
     }
-    return (symbol.flags & ts.SymbolFlags.EnumMember) !== 0;
+    return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.EnumMember);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-unnecessary-type-conversion',

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

@@ -689,8 +689,7 @@ exports.default = (0, util_1.createRule)({
                         continue;
                     }
                     // skip ignored parameters
-                    if (def.name.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        options.caughtErrorsIgnorePattern?.test(def.name.name)) {
+                    if (options.caughtErrorsIgnorePattern?.test(def.name.name)) {
                         if (options.reportUsedIgnorePattern && used) {
                             report(variable, {
                                 messageId: 'usedIgnoredVar',

package/dist/rules/no-useless-default-assignment.js

@@ -116,7 +116,7 @@ exports.default = (0, util_1.createRule)({
                                 paramSymbol.valueDeclaration.dotDotDotToken != null) {
                                 return;
                             }
-                            if ((paramSymbol.flags & ts.SymbolFlags.Optional) === 0) {
+                            if (!tsutils.isSymbolFlagSet(paramSymbol, ts.SymbolFlags.Optional)) {
                                 const paramType = checker.getTypeOfSymbol(paramSymbol);
                                 if (!canBeUndefined(paramType)) {
                                     reportUselessDefaultAssignment(node, 'parameter');
@@ -169,7 +169,7 @@ exports.default = (0, util_1.createRule)({
             if (!symbol) {
                 return null;
             }
-            if (symbol.flags & ts.SymbolFlags.Optional &&
+            if (tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Optional) &&
                 hasConditionalInitializer(objectPattern)) {
                 return null;
             }

package/dist/rules/non-nullable-type-assertion-style.js

@@ -63,7 +63,7 @@ exports.default = (0, util_1.createRule)({
             return tsutils.unionConstituents(type);
         };
         const couldBeNullish = (type) => {
-            if (type.flags & ts.TypeFlags.TypeParameter) {
+            if (tsutils.isTypeFlagSet(type, ts.TypeFlags.TypeParameter)) {
                 const constraint = type.getConstraint();
                 return constraint == null || couldBeNullish(constraint);
             }
@@ -75,10 +75,10 @@ exports.default = (0, util_1.createRule)({
                 }
                 return false;
             }
-            return (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+            return tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined);
         };
         const sameTypeWithoutNullish = (assertedTypes, originalTypes) => {
-            const nonNullishOriginalTypes = originalTypes.filter(type => (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
+            const nonNullishOriginalTypes = originalTypes.filter(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined));
             if (nonNullishOriginalTypes.length === originalTypes.length) {
                 return false;
             }

package/dist/rules/only-throw-error.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
 const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
@@ -133,7 +134,7 @@ exports.default = (0, util_1.createRule)({
             if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program)) {
                 return;
             }
-            if (type.flags & ts.TypeFlags.Undefined) {
+            if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Undefined)) {
                 context.report({ node, messageId: 'undef' });
                 return;
             }

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

@@ -131,8 +131,7 @@ exports.default = util.createRule({
          * @returns `true` if the expected type was void function.
          */
         function checkExpressionNode(node) {
-            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-            const expectedType = checker.getContextualType(tsNode);
+            const expectedType = parserServices.getContextualType(node);
             if (expectedType != null && isVoidReturningFunctionType(expectedType)) {
                 reportIfNonVoidFunction(node);
                 return true;
@@ -206,8 +205,7 @@ exports.default = util.createRule({
                     // Don't check object methods with computed name.
                     return;
                 }
-                const objTsNode = propTsNode.parent;
-                const objType = checker.getContextualType(objTsNode);
+                const objType = parserServices.getContextualType(propNode.parent);
                 if (objType == null) {
                     // Expected object type is unknown.
                     return;

package/dist/util/assertionFunctionUtils.js

@@ -57,8 +57,7 @@ function findTruthinessAssertedArgument(services, node) {
         return undefined;
     }
     const checker = services.program.getTypeChecker();
-    const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-    const signature = checker.getResolvedSignature(tsNode);
+    const signature = services.getResolvedSignature(node);
     if (signature == null) {
         return undefined;
     }
@@ -92,8 +91,7 @@ function findTypeGuardAssertedArgument(services, node) {
         return undefined;
     }
     const checker = services.program.getTypeChecker();
-    const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-    const callSignature = checker.getResolvedSignature(tsNode);
+    const callSignature = services.getResolvedSignature(node);
     if (callSignature == null) {
         return undefined;
     }

package/dist/util/class-scope-analyzer/classScopeAnalyzer.js

@@ -318,6 +318,20 @@ class ThisScope extends scope_manager_1.Visitor {
     /////////////////////
     // Visit selectors //
     /////////////////////
+    AssignmentExpression(node) {
+        this.visitChildren(node);
+        if (node.right.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+            node.left.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            this.handleThisDestructuring(node.left);
+        }
+    }
+    AssignmentPattern(node) {
+        this.visitChildren(node);
+        if (node.right.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+            node.left.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            this.handleThisDestructuring(node.left);
+        }
+    }
     ClassDeclaration(node) {
         this.visitClass(node);
     }
@@ -391,6 +405,39 @@ class ThisScope extends scope_manager_1.Visitor {
     StaticBlock(node) {
         this.visitIntermediate(node);
     }
+    VariableDeclarator(node) {
+        this.visitChildren(node);
+        if (node.init?.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+            node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            this.handleThisDestructuring(node.id);
+        }
+    }
+    /**
+     * Handles destructuring from `this` in ObjectPattern.
+     * Example: const { property } = this;
+     */
+    handleThisDestructuring(pattern) {
+        if (this.thisContext == null) {
+            return;
+        }
+        for (const prop of pattern.properties) {
+            if (prop.type !== utils_1.AST_NODE_TYPES.Property) {
+                continue;
+            }
+            if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier || prop.computed) {
+                continue;
+            }
+            const memberKey = (0, types_1.publicKey)(prop.key.name);
+            const members = this.isStaticThisContext
+                ? this.thisContext.members.static
+                : this.thisContext.members.instance;
+            const member = members.get(memberKey);
+            if (member == null) {
+                continue;
+            }
+            countReference(prop.key, member);
+        }
+    }
 }
 /**
  * Any other scope that is not a class scope

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.53.2-alpha.1",
+  "version": "8.53.2-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.53.2-alpha.1",
-    "@typescript-eslint/type-utils": "8.53.2-alpha.1",
-    "@typescript-eslint/utils": "8.53.2-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.53.2-alpha.1",
+    "@typescript-eslint/scope-manager": "8.53.2-alpha.10",
+    "@typescript-eslint/type-utils": "8.53.2-alpha.10",
+    "@typescript-eslint/utils": "8.53.2-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.53.2-alpha.10",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.4.0"
@@ -70,8 +70,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.53.2-alpha.1",
-    "@typescript-eslint/rule-tester": "8.53.2-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.53.2-alpha.10",
+    "@typescript-eslint/rule-tester": "8.53.2-alpha.10",
     "@vitest/coverage-v8": "^3.2.4",
     "ajv": "^6.12.6",
     "eslint": "*",
@@ -81,7 +81,7 @@
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-mdx": "^3.0.0",
     "micromark-extension-mdxjs": "^3.0.0",
-    "prettier": "3.7.4",
+    "prettier": "3.8.0",
     "rimraf": "*",
     "title-case": "^4.3.2",
     "tsx": "*",
@@ -90,7 +90,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.53.2-alpha.1",
+    "@typescript-eslint/parser": "^8.53.2-alpha.10",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },