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

package/dist/index.d.ts

@@ -785,7 +785,7 @@ declare const _default: {
         'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unsafe-member-access").MessageIds, import("./rules/no-unsafe-member-access").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/raw-plugin.d.ts

@@ -808,7 +808,7 @@ declare const _default: {
             'no-unsafe-declaration-merging': TSESLint.RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-enum-comparison': TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-function-type': TSESLint.RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
-            'no-unsafe-member-access': TSESLint.RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-unsafe-member-access': TSESLint.RuleModule<import("./rules/no-unsafe-member-access").MessageIds, import("./rules/no-unsafe-member-access").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-return': TSESLint.RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-type-assertion': TSESLint.RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-unary-minus': TSESLint.RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

package/dist/rules/index.d.ts

@@ -115,7 +115,7 @@ declare const rules: {
     'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-member-access").MessageIds, import("./no-unsafe-member-access").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

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

@@ -72,7 +72,7 @@ exports.default = (0, util_1.createRule)({
                     },
                     ignoredTypeNames: {
                         type: 'array',
-                        description: 'Stringified regular expressions of type names to ignore.',
+                        description: 'Stringified type names to ignore.',
                         items: {
                             type: 'string',
                         },

package/dist/rules/no-deprecated.js

@@ -149,6 +149,9 @@ exports.default = (0, util_1.createRule)({
                 case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
                 case utils_1.AST_NODE_TYPES.TSTypeParameter:
                     return true;
+                // treat `export import Bar = Foo;` (and `import Foo = require('...')`) as declarations
+                case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+                    return parent.id === node;
                 default:
                     return false;
             }

package/dist/rules/no-floating-promises.js

@@ -35,7 +35,6 @@ 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");
 const promiseUtils_1 = require("../util/promiseUtils");
 const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
@@ -141,8 +140,9 @@ exports.default = (0, util_1.createRule)({
                                 {
                                     messageId: 'floatingFixVoid',
                                     fix(fixer) {
-                                        const tsNode = services.esTreeNodeToTSNodeMap.get(node.expression);
-                                        if (isHigherPrecedenceThanUnary(tsNode)) {
+                                        if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
+                                            (0, util_1.getOperatorPrecedenceForNode)(expression) >
+                                                util_1.OperatorPrecedence.Unary) {
                                             return fixer.insertTextBefore(node, 'void ');
                                         }
                                         return [
@@ -180,8 +180,8 @@ exports.default = (0, util_1.createRule)({
                 expression.operator === 'void') {
                 return fixer.replaceTextRange([expression.range[0], expression.range[0] + 4], 'await');
             }
-            const tsNode = services.esTreeNodeToTSNodeMap.get(node.expression);
-            if (isHigherPrecedenceThanUnary(tsNode)) {
+            if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
+                (0, util_1.getOperatorPrecedenceForNode)(expression) > util_1.OperatorPrecedence.Unary) {
                 return fixer.insertTextBefore(node, 'await ');
             }
             return [
@@ -199,13 +199,6 @@ exports.default = (0, util_1.createRule)({
             }
             return (0, util_1.typeMatchesSomeSpecifier)(type, allowForKnownSafeCalls, services.program);
         }
-        function isHigherPrecedenceThanUnary(node) {
-            const operator = ts.isBinaryExpression(node)
-                ? node.operatorToken.kind
-                : ts.SyntaxKind.Unknown;
-            const nodePrecedence = (0, util_1.getOperatorPrecedence)(node.kind, operator);
-            return nodePrecedence > util_1.OperatorPrecedence.Unary;
-        }
         function isAsyncIife(node) {
             if (node.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                 return false;

package/dist/rules/no-unsafe-member-access.d.ts

@@ -1,2 +1,8 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export type Options = [
+    {
+        allowOptionalChaining?: boolean;
+    }
+];
+export type MessageIds = 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 export default _default;

package/dist/rules/no-unsafe-member-access.js

@@ -40,6 +40,7 @@ var State;
 (function (State) {
     State[State["Unsafe"] = 1] = "Unsafe";
     State[State["Safe"] = 2] = "Safe";
+    State[State["Chained"] = 3] = "Chained";
 })(State || (State = {}));
 function createDataType(type) {
     const isErrorType = tsutils.isIntrinsicErrorType(type);
@@ -62,15 +63,41 @@ exports.default = (0, util_1.createRule)({
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
             ].join('\n'),
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowOptionalChaining: {
+                        type: 'boolean',
+                        description: 'Whether to allow `?.` optional chains on `any` values.',
+                    },
+                },
+            },
+        ],
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [
+        {
+            allowOptionalChaining: false,
+        },
+    ],
+    create(context, [{ allowOptionalChaining }]) {
         const services = (0, util_1.getParserServices)(context);
         const compilerOptions = services.program.getCompilerOptions();
         const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
         const stateCache = new Map();
+        // Case notes:
+        // value?.outer.middle.inner
+        // The ChainExpression is a child of the root expression, and a parent of all the MemberExpressions.
+        // But the left-most expression is what we want to report on: the inner-most expressions.
+        // In fact, this is true even if the chain is on the inside!
+        // value.outer.middle?.inner;
+        // It was already true that every `object` (MemberExpression) has optional: boolean
         function checkMemberExpression(node) {
+            if (allowOptionalChaining && node.optional) {
+                stateCache.set(node, State.Chained);
+                return State.Chained;
+            }
             const cachedState = stateCache.get(node);
             if (cachedState) {
                 return cachedState;
@@ -113,6 +140,10 @@ exports.default = (0, util_1.createRule)({
             // ignore MemberExpressions with ancestors of type `TSClassImplements` or `TSInterfaceHeritage`
             'MemberExpression:not(TSClassImplements MemberExpression, TSInterfaceHeritage MemberExpression)': checkMemberExpression,
             'MemberExpression[computed = true] > *.property'(node) {
+                if (allowOptionalChaining &&
+                    node.parent.optional) {
+                    return;
+                }
                 if (
                 // x[1]
                 node.type === utils_1.AST_NODE_TYPES.Literal ||

package/dist/rules/no-unused-vars.d.ts

@@ -9,6 +9,7 @@ export type Options = [
         destructuredArrayIgnorePattern?: string;
         ignoreClassWithStaticInitBlock?: boolean;
         ignoreRestSiblings?: boolean;
+        ignoreUsingDeclarations?: boolean;
         reportUsedIgnorePattern?: boolean;
         vars?: 'all' | 'local';
         varsIgnorePattern?: string;

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

@@ -60,6 +60,10 @@ exports.default = (0, util_1.createRule)({
                                 type: 'boolean',
                                 description: 'Whether to ignore sibling properties in `...` destructurings.',
                             },
+                            ignoreUsingDeclarations: {
+                                type: 'boolean',
+                                description: 'Whether to ignore using or await using declarations.',
+                            },
                             reportUsedIgnorePattern: {
                                 type: 'boolean',
                                 description: 'Whether to report variables that match any of the valid ignore pattern options if they have been used.',
@@ -88,6 +92,7 @@ exports.default = (0, util_1.createRule)({
                 caughtErrors: 'all',
                 ignoreClassWithStaticInitBlock: false,
                 ignoreRestSiblings: false,
+                ignoreUsingDeclarations: false,
                 reportUsedIgnorePattern: false,
                 vars: 'all',
             };
@@ -99,6 +104,9 @@ exports.default = (0, util_1.createRule)({
                 options.args = firstOption.args ?? options.args;
                 options.ignoreRestSiblings =
                     firstOption.ignoreRestSiblings ?? options.ignoreRestSiblings;
+                options.ignoreUsingDeclarations =
+                    firstOption.ignoreUsingDeclarations ??
+                        options.ignoreUsingDeclarations;
                 options.caughtErrors = firstOption.caughtErrors ?? options.caughtErrors;
                 options.ignoreClassWithStaticInitBlock =
                     firstOption.ignoreClassWithStaticInitBlock ??
@@ -382,6 +390,11 @@ exports.default = (0, util_1.createRule)({
                     }
                     continue;
                 }
+                if (def.type === utils_1.TSESLint.Scope.DefinitionType.Variable &&
+                    options.ignoreUsingDeclarations &&
+                    (def.parent.kind === 'await using' || def.parent.kind === 'using')) {
+                    continue;
+                }
                 if (hasRestSpreadSibling(variable)) {
                     continue;
                 }

package/dist/rules/unbound-method.js

@@ -99,7 +99,10 @@ const isNotImported = (symbol, currentSourceFile) => {
     return (!!currentSourceFile &&
         currentSourceFile !== valueDeclaration.getSourceFile());
 };
-const BASE_MESSAGE = 'Avoid referencing unbound methods which may cause unintentional scoping of `this`.';
+const BASE_MESSAGE = [
+    `A method that is not declared with \`this: void\` may cause unintentional scoping of \`this\` when separated from its object.`,
+    `Consider using an arrow function or explicitly \`.bind()\`ing the method to avoid calling the method with an unintended \`this\` value. `,
+].join('\n');
 exports.default = (0, util_1.createRule)({
     name: 'unbound-method',
     meta: {
@@ -111,7 +114,7 @@ exports.default = (0, util_1.createRule)({
         },
         messages: {
             unbound: BASE_MESSAGE,
-            unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
+            unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf a function does not access \`this\`, it can be annotated with \`this: void\`.`,
         },
         schema: [
             {

package/dist/util/getOperatorPrecedence.d.ts

@@ -28,6 +28,10 @@ export declare enum OperatorPrecedence {
     Lowest = 0,
     Invalid = -1
 }
+/**
+ * Note that this does not take into account parenthesization. You should check
+ * for parenthesization separately if it's relevant to your usage.
+ */
 export declare function getOperatorPrecedenceForNode(node: TSESTree.Node): OperatorPrecedence;
 type TSESTreeOperatorKind = ValueOf<TSESTree.BinaryOperatorToText> | ValueOf<TSESTree.PunctuatorTokenToText>;
 export declare function getOperatorPrecedence(nodeKind: SyntaxKind, operatorKind: SyntaxKind, hasArguments?: boolean): OperatorPrecedence;

package/dist/util/getOperatorPrecedence.js

@@ -175,6 +175,10 @@ var OperatorPrecedence;
     // parsing to stop.
     OperatorPrecedence[OperatorPrecedence["Invalid"] = -1] = "Invalid";
 })(OperatorPrecedence || (exports.OperatorPrecedence = OperatorPrecedence = {}));
+/**
+ * Note that this does not take into account parenthesization. You should check
+ * for parenthesization separately if it's relevant to your usage.
+ */
 function getOperatorPrecedenceForNode(node) {
     switch (node.type) {
         case utils_1.AST_NODE_TYPES.SpreadElement:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.45.1-alpha.1",
+  "version": "8.45.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.45.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.45.1-alpha.1",
-    "@typescript-eslint/utils": "8.45.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.45.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.45.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.45.1-alpha.10",
+    "@typescript-eslint/utils": "8.45.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.45.1-alpha.10",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.45.1-alpha.1",
-    "@typescript-eslint/rule-tester": "8.45.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.45.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.45.1-alpha.10",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.45.1-alpha.1",
+    "@typescript-eslint/parser": "^8.45.1-alpha.10",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },