@typescript-eslint/eslint-plugin 8.65.1-alpha.9 → 8.66.1-alpha.0

package/dist/rules/class-literal-property-style.js

@@ -113,22 +113,29 @@ exports.default = (0, util_1.createRule)({
                     if (hasDuplicateKeySetter) {
                         return;
                     }
+                    const getterBody = node.value.body;
                     context.report({
                         node: node.key,
                         messageId: 'preferFieldStyle',
-                        suggest: [
-                            {
+                        ...(0, util_1.getFixOrSuggest)({
+                            fixOrSuggest: node.decorators.length === 0 ? 'suggest' : 'none',
+                            suggestion: {
                                 messageId: 'preferFieldStyleSuggestion',
                                 fix(fixer) {
                                     const name = context.sourceCode.getText(node.key);
+                                    const closingParen = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.value.returnType ?? getterBody), 'Getter should have a closing parenthesis.');
+                                    const betweenParensAndBody = context.sourceCode
+                                        .getText()
+                                        .slice(closingParen.range[1], getterBody.range[0]);
                                     let text = '';
                                     text += printNodeModifiers(node, 'readonly');
                                     text += node.computed ? `[${name}]` : name;
-                                    text += ` = ${context.sourceCode.getText(argument)};`;
+                                    text += betweenParensAndBody;
+                                    text += `= ${context.sourceCode.getText(argument)};`;
                                     return fixer.replaceText(node, text);
                                 },
                             },
-                        ],
+                        }),
                     });
                 },
             }),

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

@@ -233,7 +233,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 const typeFlag = builtInTypeFlags[nodeCallee.name];
                 const scope = context.sourceCode.getScope(node);
-                const variable = scope.set.get(nodeCallee.name);
+                const variable = utils_1.ASTUtils.findVariable(scope, nodeCallee.name);
                 if (!!variable?.defs.length ||
                     !doesUnderlyingTypeMatchFlag((0, util_1.getConstrainedTypeAtLocation)(services, node.arguments[0]), typeFlag)) {
                     return;

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

@@ -356,6 +356,11 @@ function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages, f
                     // They have properties, so we need to avoid double-counting.
                     visitType(type.templateType ?? type.constraintType, false);
                 }
+                // TS doesn't count mapped types key remapping (`{[K in 'a' as T]: K}`)
+                // but handles this under `MappedType.nameType`, so we need to visit that too.
+                if (type.nameType) {
+                    visitType(type.nameType, false);
+                }
             }
             visitType(type.getNumberIndexType(), true);
             visitType(type.getStringIndexType(), true);

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

@@ -138,21 +138,24 @@ exports.default = (0, util_1.createRule)({
                             signatures[0].getDeclaration() === tsFunc) {
                             return;
                         }
-                        const params = signatures[0].getParameters();
-                        if (paramIndex < params.length) {
+                        const defaultCanBeUsed = signatures.some(signature => {
+                            const params = signature.getParameters();
+                            if (paramIndex >= params.length) {
+                                return true;
+                            }
                             const paramSymbol = params[paramIndex];
                             if (paramSymbol.valueDeclaration &&
-                                ts.isParameter(paramSymbol.valueDeclaration) &&
-                                paramSymbol.valueDeclaration.dotDotDotToken != null) {
-                                return;
+                                (0, util_1.isRestParameterDeclaration)(paramSymbol.valueDeclaration)) {
+                                return true;
                             }
-                            if (!tsutils.isSymbolFlagSet(paramSymbol, ts.SymbolFlags.Optional)) {
-                                const paramType = checker.getTypeOfSymbol(paramSymbol);
-                                if (!tsutils.isTypeParameter(paramType) &&
-                                    !canBeUndefined(paramType)) {
-                                    reportUselessDefaultAssignment(node, 'parameter');
-                                }
+                            if (tsutils.isSymbolFlagSet(paramSymbol, ts.SymbolFlags.Optional)) {
+                                return true;
                             }
+                            const paramType = checker.getTypeOfSymbol(paramSymbol);
+                            return (tsutils.isTypeParameter(paramType) || canBeUndefined(paramType));
+                        });
+                        if (!defaultCanBeUsed) {
+                            reportUselessDefaultAssignment(node, 'parameter');
                         }
                     }
                 }

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

@@ -468,7 +468,7 @@ function isBuiltInBooleanCall(node, context) {
         node.callee.name === 'Boolean' &&
         node.arguments[0]) {
         const scope = context.sourceCode.getScope(node);
-        const variable = scope.set.get(utils_1.AST_TOKEN_TYPES.Boolean);
+        const variable = utils_1.ASTUtils.findVariable(scope, node.callee);
         return variable == null || variable.defs.length === 0;
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.65.1-alpha.9",
+  "version": "8.66.1-alpha.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -49,10 +49,10 @@
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0",
-    "@typescript-eslint/scope-manager": "8.65.1-alpha.9",
-    "@typescript-eslint/utils": "8.65.1-alpha.9",
-    "@typescript-eslint/visitor-keys": "8.65.1-alpha.9",
-    "@typescript-eslint/type-utils": "8.65.1-alpha.9"
+    "@typescript-eslint/scope-manager": "8.66.1-alpha.0",
+    "@typescript-eslint/type-utils": "8.66.1-alpha.0",
+    "@typescript-eslint/utils": "8.66.1-alpha.0",
+    "@typescript-eslint/visitor-keys": "8.66.1-alpha.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
@@ -76,13 +76,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.65.1-alpha.9",
-    "@typescript-eslint/rule-tester": "8.65.1-alpha.9"
+    "@typescript-eslint/rule-tester": "8.66.1-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.66.1-alpha.0"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0",
-    "@typescript-eslint/parser": "^8.65.1-alpha.9"
+    "@typescript-eslint/parser": "^8.66.1-alpha.0"
   },
   "funding": {
     "type": "opencollective",