@typescript-eslint/eslint-plugin 8.53.2-alpha.8 → 8.53.2-alpha.9

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-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-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.53.2-alpha.8",
+  "version": "8.53.2-alpha.9",
   "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.8",
-    "@typescript-eslint/type-utils": "8.53.2-alpha.8",
-    "@typescript-eslint/utils": "8.53.2-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.53.2-alpha.8",
+    "@typescript-eslint/scope-manager": "8.53.2-alpha.9",
+    "@typescript-eslint/type-utils": "8.53.2-alpha.9",
+    "@typescript-eslint/utils": "8.53.2-alpha.9",
+    "@typescript-eslint/visitor-keys": "8.53.2-alpha.9",
     "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.8",
-    "@typescript-eslint/rule-tester": "8.53.2-alpha.8",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.53.2-alpha.9",
+    "@typescript-eslint/rule-tester": "8.53.2-alpha.9",
     "@vitest/coverage-v8": "^3.2.4",
     "ajv": "^6.12.6",
     "eslint": "*",
@@ -90,7 +90,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.53.2-alpha.8",
+    "@typescript-eslint/parser": "^8.53.2-alpha.9",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },