@typescript-eslint/eslint-plugin 8.67.1-alpha.3 → 8.67.1-alpha.5

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

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

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

@@ -37,42 +37,6 @@ 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: {
@@ -614,9 +578,9 @@ exports.default = (0, util_1.createRule)({
                     // 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);
+                        (0, util_1.isStartOfExpressionStatement)(node);
                     const breaksArrowFunctionBody = firstOperandToken.value === '{' &&
-                        isAtArrowFunctionBodyStart(node, context.sourceCode);
+                        (0, util_1.isStartOfArrowFunctionBody)(node, context.sourceCode);
                     const needsParens = breaksExpressionStatement || breaksArrowFunctionBody;
                     const fixes = [];
                     if (needsParens) {

package/dist/rules/return-await.js

@@ -220,7 +220,18 @@ exports.default = (0, util_1.createRule)({
             if (nextToken) {
                 endAt = nextToken.range[0];
             }
-            return fixer.removeRange([startAt, endAt]);
+            const awaitRemovalFix = fixer.removeRange([startAt, endAt]);
+            const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitToken), util_1.NullThrowsReasons.MissingToken('operand', 'await expression'));
+            const shouldWrapInParentheses = (0, util_1.isOpeningBraceToken)(firstOperandToken) &&
+                (0, util_1.isStartOfArrowFunctionBody)(node, context.sourceCode);
+            if (shouldWrapInParentheses) {
+                return [
+                    awaitRemovalFix,
+                    fixer.insertTextBefore(node.argument, '('),
+                    fixer.insertTextAfter(node.argument, ')'),
+                ];
+            }
+            return awaitRemovalFix;
         }
         function insertAwait(fixer, node, isHighPrecedence) {
             if (isHighPrecedence) {

package/dist/rules/unified-signatures.js

@@ -14,7 +14,7 @@ exports.default = (0, util_1.createRule)({
         messages: {
             omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
             omittingSingleParameter: '{{failureStringStart}} with an optional parameter.',
-            singleParameterDifference: '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
+            singleParameterDifference: '{{failureStringStart}} taking `{{types}}`.',
         },
         schema: [
             {
@@ -57,20 +57,15 @@ exports.default = (0, util_1.createRule)({
                     case 'single-parameter-difference': {
                         const { p0, p1 } = unify;
                         const lineOfOtherOverload = only2 ? undefined : p0.loc.start.line;
-                        const typeAnnotation0 = isTSParameterProperty(p0)
-                            ? p0.parameter.typeAnnotation
-                            : p0.typeAnnotation;
-                        const typeAnnotation1 = isTSParameterProperty(p1)
-                            ? p1.parameter.typeAnnotation
-                            : p1.typeAnnotation;
+                        const typeAnnotation0 = getParameterTypeAnnotation(p0);
+                        const typeAnnotation1 = getParameterTypeAnnotation(p1);
                         context.report({
                             loc: p1.loc,
                             node: p1,
                             messageId: 'singleParameterDifference',
                             data: {
                                 failureStringStart: failureStringStart(lineOfOtherOverload),
-                                type1: context.sourceCode.getText(typeAnnotation0?.typeAnnotation),
-                                type2: context.sourceCode.getText(typeAnnotation1?.typeAnnotation),
+                                types: getUnifiedTypeText(typeAnnotation0, typeAnnotation1),
                             },
                         });
                         break;
@@ -114,7 +109,7 @@ exports.default = (0, util_1.createRule)({
                 return undefined;
             }
             return a.params.length === b.params.length
-                ? signaturesDifferBySingleParameter(a.params, b.params)
+                ? signaturesDifferBySingleParameter(a, b)
                 : signaturesDifferByOptionalOrRestParameter(a, b);
         }
         function signaturesCanBeUnified(a, b, isTypeParameter) {
@@ -138,7 +133,7 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
             }
-            return (typesAreEqual(a.returnType, b.returnType) &&
+            return (typesAreEqual(a.returnType?.typeAnnotation, b.returnType?.typeAnnotation) &&
                 // Must take the same type parameters.
                 // If one uses a type parameter (from outside) and the other doesn't, they shouldn't be joined.
                 (0, util_1.arraysAreEqual)(aTypeParams, bTypeParams, typeParametersAreEqual) &&
@@ -146,7 +141,9 @@ exports.default = (0, util_1.createRule)({
                     signatureUsesTypeParameter(b, isTypeParameter));
         }
         /** Detect `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`. */
-        function signaturesDifferBySingleParameter(types1, types2) {
+        function signaturesDifferBySingleParameter(signature0, signature1) {
+            const types1 = signature0.params;
+            const types2 = signature1.params;
             const firstParam1 = types1[0];
             const firstParam2 = types2[0];
             // exempt signatures with `this: void` from the rule
@@ -170,6 +167,39 @@ exports.default = (0, util_1.createRule)({
                 ? { kind: 'single-parameter-difference', p0: a, p1: b }
                 : undefined;
         }
+        function getParameterTypeAnnotation(parameter) {
+            return isTSParameterProperty(parameter)
+                ? parameter.parameter.typeAnnotation?.typeAnnotation
+                : parameter.typeAnnotation?.typeAnnotation;
+        }
+        function getUnifiedTypeText(type0, type1) {
+            // When a signature's parameter has no type annotation
+            if (type0 == null || type1 == null) {
+                return getUnionMemberText((0, util_1.nullThrows)(type0 ?? type1, 'Expected a type annotation for one of the parameters, but both were undefined'));
+            }
+            const members = [...getUnionMembers(type0), ...getUnionMembers(type1)];
+            const uniqueMembers = [];
+            for (const member of members) {
+                if (!uniqueMembers.some(other => typesAreEqual(other, member))) {
+                    uniqueMembers.push(member);
+                }
+            }
+            return uniqueMembers
+                .map(member => getUnionMemberText(member))
+                .join(' | ');
+        }
+        function getUnionMembers(type) {
+            return type.type === utils_1.AST_NODE_TYPES.TSUnionType
+                ? type.types.flatMap(getUnionMembers)
+                : [type];
+        }
+        function getUnionMemberText(type) {
+            const text = context.sourceCode.getText(type);
+            const needsParentheses = type.type === utils_1.AST_NODE_TYPES.TSConditionalType ||
+                type.type === utils_1.AST_NODE_TYPES.TSConstructorType ||
+                type.type === utils_1.AST_NODE_TYPES.TSFunctionType;
+            return needsParentheses ? `(${text})` : text;
+        }
         function isThisParam(param) {
             return param?.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this';
         }
@@ -209,15 +239,7 @@ exports.default = (0, util_1.createRule)({
                 }
             }
             for (let i = 0; i < minLength; i++) {
-                const sig1i = sig1[i];
-                const sig2i = sig2[i];
-                const typeAnnotation1 = isTSParameterProperty(sig1i)
-                    ? sig1i.parameter.typeAnnotation
-                    : sig1i.typeAnnotation;
-                const typeAnnotation2 = isTSParameterProperty(sig2i)
-                    ? sig2i.parameter.typeAnnotation
-                    : sig2i.typeAnnotation;
-                if (!typesAreEqual(typeAnnotation1, typeAnnotation2)) {
+                if (!typesAreEqual(getParameterTypeAnnotation(sig1[i]), getParameterTypeAnnotation(sig2[i]))) {
                     return undefined;
                 }
             }
@@ -265,14 +287,8 @@ exports.default = (0, util_1.createRule)({
             return node.type === utils_1.AST_NODE_TYPES.TSParameterProperty;
         }
         function parametersAreEqual(a, b) {
-            const typeAnnotationA = isTSParameterProperty(a)
-                ? a.parameter.typeAnnotation
-                : a.typeAnnotation;
-            const typeAnnotationB = isTSParameterProperty(b)
-                ? b.parameter.typeAnnotation
-                : b.typeAnnotation;
             return (parametersHaveEqualSigils(a, b) &&
-                typesAreEqual(typeAnnotationA, typeAnnotationB));
+                typesAreEqual(getParameterTypeAnnotation(a), getParameterTypeAnnotation(b)));
         }
         /** True for optional/rest parameters. */
         function parameterMayBeMissing(p) {
@@ -300,8 +316,7 @@ exports.default = (0, util_1.createRule)({
             return (a === b ||
                 (a != null &&
                     b != null &&
-                    context.sourceCode.getText(a.typeAnnotation) ===
-                        context.sourceCode.getText(b.typeAnnotation)));
+                    context.sourceCode.getText(a) === context.sourceCode.getText(b)));
         }
         function constraintsAreEqual(a, b) {
             return a === b || (a != null && a.type === b?.type);

package/dist/util/index.d.ts

@@ -18,6 +18,7 @@ export * from './isAssignee';
 export * from './isConditionalTest';
 export * from './isNodeEqual';
 export * from './isNullLiteral';
+export * from './isStartOfArrowFunctionBody';
 export * from './isStartOfExpressionStatement';
 export * from './isUndefinedIdentifier';
 export * from './misc';

package/dist/util/index.js

@@ -35,6 +35,7 @@ __exportStar(require("./isAssignee"), exports);
 __exportStar(require("./isConditionalTest"), exports);
 __exportStar(require("./isNodeEqual"), exports);
 __exportStar(require("./isNullLiteral"), exports);
+__exportStar(require("./isStartOfArrowFunctionBody"), exports);
 __exportStar(require("./isStartOfExpressionStatement"), exports);
 __exportStar(require("./isUndefinedIdentifier"), exports);
 __exportStar(require("./misc"), exports);

package/dist/util/isStartOfArrowFunctionBody.d.ts

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

package/dist/util/isStartOfArrowFunctionBody.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStartOfArrowFunctionBody = isStartOfArrowFunctionBody;
+const utils_1 = require("@typescript-eslint/utils");
+const astUtils_1 = require("./astUtils");
+function isStartOfArrowFunctionBody(node, sourceCode) {
+    let current = node;
+    while (true) {
+        if ((0, astUtils_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;
+    }
+}

package/package.json

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