@typescript-eslint/eslint-plugin 8.62.1-alpha.0 → 8.62.1-alpha.1

package/dist/rules/no-unnecessary-boolean-literal-compare.js

@@ -212,22 +212,33 @@ exports.default = (0, util_1.createRule)({
                         // we'll build up the replacement text from the compared expression outwards.
                         let replacementText = context.sourceCode.getText(comparison.expression);
                         let mayNeedParentheses = !(0, util_1.isStrongPrecedenceNode)(comparison.expression);
-                        // In maybeNullish === false, nullish values have the same truth table
-                        // as `true`.
-                        if (comparison.expressionIsNullableBoolean &&
-                            comparison.booleanLiteral === 'false') {
+                        const fixWouldReturnExpressionDirectly = !isOverallNegated && comparison.expressionIsNullableBoolean;
+                        if (fixWouldReturnExpressionDirectly &&
+                            !(0, util_1.isConditionalTest)(mutatedNode)) {
                             if (mayNeedParentheses) {
                                 replacementText = parenthesize(replacementText);
                             }
-                            replacementText = `${replacementText} ?? true`;
+                            replacementText = `${replacementText} ?? false`;
                             mayNeedParentheses = true;
                         }
-                        if (isOverallNegated) {
-                            if (mayNeedParentheses) {
-                                replacementText = parenthesize(replacementText);
+                        else {
+                            // In maybeNullish === false, nullish values have the same truth table
+                            // as `true`.
+                            if (comparison.expressionIsNullableBoolean &&
+                                comparison.booleanLiteral === 'false') {
+                                if (mayNeedParentheses) {
+                                    replacementText = parenthesize(replacementText);
+                                }
+                                replacementText = `${replacementText} ?? true`;
+                                mayNeedParentheses = true;
+                            }
+                            if (isOverallNegated) {
+                                if (mayNeedParentheses) {
+                                    replacementText = parenthesize(replacementText);
+                                }
+                                replacementText = `!${replacementText}`;
+                                mayNeedParentheses = false;
                             }
-                            replacementText = `!${replacementText}`;
-                            mayNeedParentheses = false;
                         }
                         if (mayNeedParentheses && (0, util_1.isWeakPrecedenceParent)(mutatedNode)) {
                             replacementText = parenthesize(replacementText);

package/dist/rules/no-unnecessary-type-assertion.d.ts

@@ -1,3 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
 export type Options = [
     {
         checkLiteralConstAssertions?: boolean;
@@ -5,7 +6,7 @@ export type Options = [
     }
 ];
 export type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

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

@@ -37,6 +37,42 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+function isAtExpressionStatementStart(node) {
+    let current = node;
+    while (true) {
+        const { parent } = current;
+        if (parent == null) {
+            return false;
+        }
+        if (parent.range[0] !== current.range[0]) {
+            return false;
+        }
+        if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+            return true;
+        }
+        current = parent;
+    }
+}
+function isAtArrowFunctionBodyStart(node, sourceCode) {
+    let current = node;
+    while (true) {
+        if ((0, util_1.isParenthesized)(current, sourceCode)) {
+            return false;
+        }
+        const { parent } = current;
+        if (parent == null) {
+            return false;
+        }
+        if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+            parent.body === current) {
+            return true;
+        }
+        if (parent.range[0] !== current.range[0]) {
+            return false;
+        }
+        current = parent;
+    }
+}
 exports.default = (0, util_1.createRule)({
     name: 'no-unnecessary-type-assertion',
     meta: {
@@ -565,17 +601,19 @@ exports.default = (0, util_1.createRule)({
                         token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation'));
                     const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
                         token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
-                    // Removing the angle-bracketed type can leave a bare object
-                    // literal in a position where `{` is parsed as a block (concise
-                    // arrow body, or the start of an expression statement). Wrap the
-                    // result in parentheses to preserve the original expression
-                    // semantics.
-                    const needsParens = node.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                        ((node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                            node.parent.body === node) ||
-                            node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) &&
-                        !(0, util_1.isParenthesized)(node, context.sourceCode) &&
-                        !(0, util_1.isParenthesized)(node.expression, context.sourceCode);
+                    // Removing the angle brackets leaves the asserted operand at the
+                    // assertion's position, so its first token leads whatever the
+                    // assertion led. A leading `{`/`function`/`class` at the start of an
+                    // expression statement is parsed as a block / function or class
+                    // declaration, and a leading `{` at the start of a concise arrow body
+                    // is parsed as a block body. In those positions the operand must be
+                    // wrapped in parentheses to stay an expression.
+                    const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(closingAngleBracket), util_1.NullThrowsReasons.MissingToken('operand', 'type assertion'));
+                    const breaksExpressionStatement = ['{', 'function', 'class'].includes(firstOperandToken.value) &&
+                        isAtExpressionStatementStart(node);
+                    const breaksArrowFunctionBody = firstOperandToken.value === '{' &&
+                        isAtArrowFunctionBodyStart(node, context.sourceCode);
+                    const needsParens = breaksExpressionStatement || breaksArrowFunctionBody;
                     const fixes = [];
                     if (needsParens) {
                         fixes.push(fixer.insertTextBefore(node, '('));

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

@@ -216,7 +216,7 @@ exports.default = (0, util_1.createRule)({
          * @param testNode The node being tested (i.e. `a`)
          */
         function isTruthinessCheckEligibleForPreferNullish({ node, testNode, }) {
-            if (ignoreConditionalTests === true && isConditionalTest(node)) {
+            if (ignoreConditionalTests === true && (0, util_1.isConditionalTest)(node)) {
                 return false;
             }
             if (ignoreBooleanCoercion === true &&
@@ -443,36 +443,6 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-function isConditionalTest(node) {
-    const parent = node.parent;
-    if (parent == null) {
-        return false;
-    }
-    if (parent.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
-        return isConditionalTest(parent);
-    }
-    if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
-        (parent.consequent === node || parent.alternate === node)) {
-        return isConditionalTest(parent);
-    }
-    if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression &&
-        parent.expressions.at(-1) === node) {
-        return isConditionalTest(parent);
-    }
-    if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
-        parent.operator === '!') {
-        return isConditionalTest(parent);
-    }
-    if ((parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
-        parent.type === utils_1.AST_NODE_TYPES.DoWhileStatement ||
-        parent.type === utils_1.AST_NODE_TYPES.IfStatement ||
-        parent.type === utils_1.AST_NODE_TYPES.ForStatement ||
-        parent.type === utils_1.AST_NODE_TYPES.WhileStatement) &&
-        parent.test === node) {
-        return true;
-    }
-    return false;
-}
 function isBooleanConstructorContext(node, context) {
     const parent = node.parent;
     if (parent == null) {

package/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -252,8 +252,10 @@ function getReportDescriptor(sourceCode, parserServices, node, operator, options
     // so we need to make sure that there is at least one operand that includes
     // `undefined`, or else we're going to change the final type - which is
     // unsafe and might cause downstream type errors.
-    else if (lastChain ||
-        lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined ||
+    else if (lastChain) {
+        useSuggestionFixer = true;
+    }
+    else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined ||
         lastOperand.comparisonType ===
             gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined ||
         lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined ||

package/dist/util/index.d.ts

@@ -15,6 +15,7 @@ export * from './getWrappingFixer';
 export * from './hasOverloadSignatures';
 export * from './isArrayMethodCallWithPredicate';
 export * from './isAssignee';
+export * from './isConditionalTest';
 export * from './isNodeEqual';
 export * from './isNullLiteral';
 export * from './isStartOfExpressionStatement';

package/dist/util/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./getWrappingFixer"), exports);
 __exportStar(require("./hasOverloadSignatures"), exports);
 __exportStar(require("./isArrayMethodCallWithPredicate"), exports);
 __exportStar(require("./isAssignee"), exports);
+__exportStar(require("./isConditionalTest"), exports);
 __exportStar(require("./isNodeEqual"), exports);
 __exportStar(require("./isNullLiteral"), exports);
 __exportStar(require("./isStartOfExpressionStatement"), exports);

package/dist/util/isConditionalTest.d.ts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isConditionalTest(node: TSESTree.Node): boolean;

package/dist/util/isConditionalTest.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConditionalTest = isConditionalTest;
+const utils_1 = require("@typescript-eslint/utils");
+function isConditionalTest(node) {
+    const parent = node.parent;
+    if (parent == null) {
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        return isConditionalTest(parent);
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+        (parent.consequent === node || parent.alternate === node)) {
+        return isConditionalTest(parent);
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression &&
+        parent.expressions.at(-1) === node) {
+        return isConditionalTest(parent);
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === '!') {
+        return isConditionalTest(parent);
+    }
+    if ((parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.DoWhileStatement ||
+        parent.type === utils_1.AST_NODE_TYPES.IfStatement ||
+        parent.type === utils_1.AST_NODE_TYPES.ForStatement ||
+        parent.type === utils_1.AST_NODE_TYPES.WhileStatement) &&
+        parent.test === node) {
+        return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.62.1-alpha.0",
+  "version": "8.62.1-alpha.1",
   "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.62.1-alpha.0",
-    "@typescript-eslint/type-utils": "8.62.1-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.62.1-alpha.0",
-    "@typescript-eslint/utils": "8.62.1-alpha.0"
+    "@typescript-eslint/scope-manager": "8.62.1-alpha.1",
+    "@typescript-eslint/type-utils": "8.62.1-alpha.1",
+    "@typescript-eslint/visitor-keys": "8.62.1-alpha.1",
+    "@typescript-eslint/utils": "8.62.1-alpha.1"
   },
   "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.62.1-alpha.0",
-    "@typescript-eslint/rule-tester": "8.62.1-alpha.0"
+    "@typescript-eslint/rule-tester": "8.62.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.62.1-alpha.1"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0",
-    "@typescript-eslint/parser": "^8.62.1-alpha.0"
+    "@typescript-eslint/parser": "^8.62.1-alpha.1"
   },
   "funding": {
     "type": "opencollective",