@typescript-eslint/eslint-plugin 8.31.2-alpha.7 → 8.32.0

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

@@ -0,0 +1,4 @@
+type MessageIds = 'suggestRemove' | 'suggestSatisfies' | 'unnecessaryTypeConversion';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=no-unnecessary-type-conversion.d.ts.map

package/dist/rules/no-unnecessary-type-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-type-conversion.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-conversion.ts"],"names":[],"mappings":"AAgBA,KAAK,UAAU,GACX,eAAe,GACf,kBAAkB,GAClB,2BAA2B,CAAC;;AAEhC,wBAsVG"}

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

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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)({
+    name: 'no-unnecessary-type-conversion',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow conversion idioms when they do not change the type or value of the expression',
+            requiresTypeChecking: true,
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            suggestRemove: 'Remove the type conversion.',
+            suggestSatisfies: 'Instead, assert that the value satisfies the {{type}} type.',
+            unnecessaryTypeConversion: '{{violation}} does not change the type or value of the {{type}}.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        function doesUnderlyingTypeMatchFlag(type, typeFlag) {
+            return tsutils
+                .unionConstituents(type)
+                .every(t => (0, util_1.isTypeFlagSet)(t, typeFlag));
+        }
+        const services = (0, util_1.getParserServices)(context);
+        function handleUnaryOperator(node, typeFlag, typeString, violation, isDoubleOperator) {
+            const outerNode = isDoubleOperator ? node.parent : node;
+            const type = services.getTypeAtLocation(node.argument);
+            if (doesUnderlyingTypeMatchFlag(type, typeFlag)) {
+                const wrappingFixerParams = {
+                    node: outerNode,
+                    innerNode: [node.argument],
+                    sourceCode: context.sourceCode,
+                };
+                context.report({
+                    loc: {
+                        start: outerNode.loc.start,
+                        end: {
+                            column: node.loc.start.column + 1,
+                            line: node.loc.start.line,
+                        },
+                    },
+                    messageId: 'unnecessaryTypeConversion',
+                    data: { type: typeString, violation },
+                    suggest: [
+                        {
+                            messageId: 'suggestRemove',
+                            fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                        },
+                        {
+                            messageId: 'suggestSatisfies',
+                            data: { type: typeString },
+                            fix: (0, util_1.getWrappingFixer)({
+                                ...wrappingFixerParams,
+                                wrap: expr => `${expr} satisfies ${typeString}`,
+                            }),
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            'AssignmentExpression[operator = "+="]'(node) {
+                if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.right.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.left],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        node,
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating a string with ''",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement
+                                    ? (fixer) => [
+                                        fixer.removeRange([
+                                            node.parent.range[0],
+                                            node.parent.range[1],
+                                        ]),
+                                    ]
+                                    : (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            'BinaryExpression[operator = "+"]'(node) {
+                if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.right.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.left],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: node.left.loc.end,
+                            end: node.loc.end,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating a string with ''",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+                else if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.left.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.right), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.right],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: node.loc.start,
+                            end: node.right.loc.start,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating '' with a string",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            CallExpression(node) {
+                const nodeCallee = node.callee;
+                const builtInTypeFlags = {
+                    BigInt: ts.TypeFlags.BigIntLike,
+                    Boolean: ts.TypeFlags.BooleanLike,
+                    Number: ts.TypeFlags.NumberLike,
+                    String: ts.TypeFlags.StringLike,
+                };
+                if (nodeCallee.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !(nodeCallee.name in builtInTypeFlags)) {
+                    return;
+                }
+                const typeFlag = builtInTypeFlags[nodeCallee.name];
+                const scope = context.sourceCode.getScope(node);
+                const variable = scope.set.get(nodeCallee.name);
+                if (!!variable?.defs.length ||
+                    !doesUnderlyingTypeMatchFlag((0, util_1.getConstrainedTypeAtLocation)(services, node.arguments[0]), typeFlag)) {
+                    return;
+                }
+                const wrappingFixerParams = {
+                    node,
+                    innerNode: [node.arguments[0]],
+                    sourceCode: context.sourceCode,
+                };
+                const typeString = nodeCallee.name.toLowerCase();
+                context.report({
+                    node: nodeCallee,
+                    messageId: 'unnecessaryTypeConversion',
+                    data: {
+                        type: nodeCallee.name.toLowerCase(),
+                        violation: `Passing a ${typeString} to ${nodeCallee.name}()`,
+                    },
+                    suggest: [
+                        {
+                            messageId: 'suggestRemove',
+                            fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                        },
+                        {
+                            messageId: 'suggestSatisfies',
+                            data: { type: typeString },
+                            fix: (0, util_1.getWrappingFixer)({
+                                ...wrappingFixerParams,
+                                wrap: expr => `${expr} satisfies ${typeString}`,
+                            }),
+                        },
+                    ],
+                });
+            },
+            'CallExpression > MemberExpression.callee > Identifier[name = "toString"].property'(node) {
+                const memberExpr = node.parent;
+                const type = (0, util_1.getConstrainedTypeAtLocation)(services, memberExpr.object);
+                if (doesUnderlyingTypeMatchFlag(type, ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node: memberExpr.parent,
+                        innerNode: [memberExpr.object],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: memberExpr.property.loc.start,
+                            end: memberExpr.parent.loc.end,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Calling a string's .toString() method",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            'UnaryExpression[operator = "!"] > UnaryExpression[operator = "!"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.BooleanLike, 'boolean', 'Using !! on a boolean', true);
+            },
+            'UnaryExpression[operator = "+"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using the unary + operator on a number', false);
+            },
+            'UnaryExpression[operator = "~"] > UnaryExpression[operator = "~"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using ~~ on a number', true);
+            },
+        };
+    },
+});

package/dist/rules/no-unsafe-assignment.js

@@ -168,7 +168,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
                     receiverProperty.key.quasis.length === 1) {
-                    key = String(receiverProperty.key.quasis[0].value.cooked);
+                    key = receiverProperty.key.quasis[0].value.cooked;
                 }
                 else {
                     // can't figure out the name, so skip it

package/dist/rules/no-unsafe-enum-comparison.js

@@ -46,13 +46,13 @@ function typeViolates(leftTypeParts, rightType) {
         (leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
 }
 function isNumberLike(type) {
-    const typeParts = tsutils.intersectionTypeParts(type);
+    const typeParts = tsutils.intersectionConstituents(type);
     return typeParts.some(typePart => {
         return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike);
     });
 }
 function isStringLike(type) {
-    const typeParts = tsutils.intersectionTypeParts(type);
+    const typeParts = tsutils.intersectionConstituents(type);
     return typeParts.some(typePart => {
         return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.String | ts.TypeFlags.StringLike);
     });
@@ -116,8 +116,8 @@ exports.default = (0, util_1.createRule)({
             // declare const something: Fruit | Vegetable;
             // something === Fruit.Apple;
             // ```
-            const leftTypeParts = tsutils.unionTypeParts(leftType);
-            const rightTypeParts = tsutils.unionTypeParts(rightType);
+            const leftTypeParts = tsutils.unionConstituents(leftType);
+            const rightTypeParts = tsutils.unionConstituents(rightType);
             // If a type exists in both sides, we consider this comparison safe:
             //
             // ```ts

package/dist/rules/no-unsafe-unary-minus.js

@@ -61,7 +61,7 @@ exports.default = util.createRule({
                 const argType = util.getConstrainedTypeAtLocation(services, node.argument);
                 const checker = services.program.getTypeChecker();
                 if (tsutils
-                    .unionTypeParts(argType)
+                    .unionConstituents(argType)
                     .some(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Any |
                     ts.TypeFlags.Never |
                     ts.TypeFlags.BigIntLike |

package/dist/rules/non-nullable-type-assertion-style.js

@@ -60,7 +60,7 @@ exports.default = (0, util_1.createRule)({
             if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
                 return undefined;
             }
-            return tsutils.unionTypeParts(type);
+            return tsutils.unionConstituents(type);
         };
         const couldBeNullish = (type) => {
             if (type.flags & ts.TypeFlags.TypeParameter) {

package/dist/rules/only-throw-error.d.ts

@@ -3,6 +3,7 @@ export type MessageIds = 'object' | 'undef';
 export type Options = [
     {
         allow?: TypeOrValueSpecifier[];
+        allowRethrowing?: boolean;
         allowThrowingAny?: boolean;
         allowThrowingUnknown?: boolean;
     }

package/dist/rules/only-throw-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAYpD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBAuFG"}
+{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBA4JG"}

package/dist/rules/only-throw-error.js

@@ -34,8 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
+const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const promiseUtils_1 = require("../util/promiseUtils");
 exports.default = (0, util_1.createRule)({
     name: 'only-throw-error',
     meta: {
@@ -59,6 +61,10 @@ exports.default = (0, util_1.createRule)({
                         ...util_1.typeOrValueSpecifiersSchema,
                         description: 'Type specifiers that can be thrown.',
                     },
+                    allowRethrowing: {
+                        type: 'boolean',
+                        description: 'Whether to allow rethrowing caught values that are not `Error` objects.',
+                    },
                     allowThrowingAny: {
                         type: 'boolean',
                         description: 'Whether to always allow throwing values typed as `any`.',
@@ -74,6 +80,7 @@ exports.default = (0, util_1.createRule)({
     defaultOptions: [
         {
             allow: [],
+            allowRethrowing: true,
             allowThrowingAny: true,
             allowThrowingUnknown: true,
         },
@@ -81,11 +88,51 @@ exports.default = (0, util_1.createRule)({
     create(context, [options]) {
         const services = (0, util_1.getParserServices)(context);
         const allow = options.allow;
+        function isRethrownError(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const scope = context.sourceCode.getScope(node);
+            const smVariable = (0, util_1.nullThrows)((0, util_1.findVariable)(scope, node), `Variable ${node.name} should exist in scope manager`);
+            const variableDefinitions = smVariable.defs.filter(def => def.isVariableDefinition);
+            if (variableDefinitions.length !== 1) {
+                return false;
+            }
+            const def = smVariable.defs[0];
+            // try { /* ... */ } catch (x) { throw x; }
+            if (def.node.type === utils_1.AST_NODE_TYPES.CatchClause) {
+                return true;
+            }
+            // promise.catch(x => { throw x; })
+            // promise.then(onFulfilled, x => { throw x; })
+            if (def.node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                def.node.params.length >= 1 &&
+                def.node.params[0] === def.name &&
+                def.node.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                const callExpression = def.node.parent;
+                const parsedPromiseHandlingCall = (0, promiseUtils_1.parseCatchCall)(callExpression, context) ??
+                    (0, promiseUtils_1.parseThenCall)(callExpression, context);
+                if (parsedPromiseHandlingCall != null) {
+                    const { object, onRejected } = parsedPromiseHandlingCall;
+                    if (onRejected === def.node) {
+                        const tsObjectNode = services.esTreeNodeToTSNodeMap.get(object);
+                        // make sure we're actually dealing with a promise
+                        if ((0, ts_api_utils_1.isThenableType)(services.program.getTypeChecker(), tsObjectNode)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
         function checkThrowArgument(node) {
             if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression ||
                 node.type === utils_1.AST_NODE_TYPES.YieldExpression) {
                 return;
             }
+            if (options.allowRethrowing && isRethrownError(node)) {
+                return;
+            }
             const type = services.getTypeAtLocation(node);
             if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program)) {
                 return;

package/dist/rules/prefer-find.js

@@ -109,7 +109,7 @@ exports.default = (0, util_1.createRule)({
          */
         function isArrayish(type) {
             let isAtLeastOneArrayishComponent = false;
-            for (const unionPart of tsutils.unionTypeParts(type)) {
+            for (const unionPart of tsutils.unionConstituents(type)) {
                 if (tsutils.isIntrinsicNullType(unionPart) ||
                     tsutils.isIntrinsicUndefinedType(unionPart)) {
                     continue;
@@ -117,7 +117,7 @@ exports.default = (0, util_1.createRule)({
                 // apparently checker.isArrayType(T[] & S[]) => false.
                 // so we need to check the intersection parts individually.
                 const isArrayOrIntersectionThereof = tsutils
-                    .intersectionTypeParts(unionPart)
+                    .intersectionConstituents(unionPart)
                     .every(intersectionPart => checker.isArrayType(intersectionPart) ||
                     checker.isTupleType(intersectionPart));
                 if (!isArrayOrIntersectionThereof) {

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

@@ -195,9 +195,9 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             if (tsutils
-                .typeParts(type)
+                .typeConstituents(type)
                 .some(t => tsutils
-                .intersectionTypeParts(t)
+                .intersectionConstituents(t)
                 .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)))) {
                 return false;
             }

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

@@ -43,7 +43,7 @@ const compareNodes_1 = require("./compareNodes");
 const gatherLogicalOperands_1 = require("./gatherLogicalOperands");
 function includesType(parserServices, node, typeFlagIn) {
     const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown;
-    const types = (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node));
+    const types = (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node));
     for (const type of types) {
         if ((0, util_1.isTypeFlagSet)(type, typeFlag)) {
             return true;

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

@@ -39,7 +39,7 @@ const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 function checkNullishAndReport(context, parserServices, { requireNullish }, maybeNullishNodes, descriptor) {
     if (!requireNullish ||
-        maybeNullishNodes.some(node => (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
+        maybeNullishNodes.some(node => (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
         context.report(descriptor);
     }
 }

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

@@ -72,7 +72,7 @@ var NullishComparisonType;
 const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
 function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) {
     const type = parserServices.getTypeAtLocation(node);
-    const types = (0, ts_api_utils_1.unionTypeParts)(type);
+    const types = (0, ts_api_utils_1.unionConstituents)(type);
     if (disallowFalseyLiteral &&
         /*
         ```

package/dist/rules/prefer-reduce-type-parameter.js

@@ -56,9 +56,9 @@ exports.default = (0, util_1.createRule)({
         const checker = services.program.getTypeChecker();
         function isArrayType(type) {
             return tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .every(unionPart => tsutils
-                .intersectionTypeParts(unionPart)
+                .intersectionConstituents(unionPart)
                 .every(t => checker.isArrayType(t) || checker.isTupleType(t)));
         }
         return {

package/dist/rules/prefer-regexp-exec.js

@@ -147,7 +147,7 @@ exports.default = (0, util_1.createRule)({
                     });
                 }
                 const argumentType = services.getTypeAtLocation(argumentNode);
-                const argumentTypes = collectArgumentTypes(tsutils.unionTypeParts(argumentType));
+                const argumentTypes = collectArgumentTypes(tsutils.unionConstituents(argumentType));
                 switch (argumentTypes) {
                     case ArgumentType.RegExp:
                         return context.report({

package/dist/rules/prefer-return-this-type.js

@@ -73,7 +73,7 @@ exports.default = (0, util_1.createRule)({
         }
         function isThisSpecifiedInParameters(originalFunc) {
             const firstArg = originalFunc.params.at(0);
-            return !!(firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
+            return (firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
         }
         function isFunctionReturningThis(originalFunc, originalClass) {
             if (isThisSpecifiedInParameters(originalFunc)) {

package/dist/rules/restrict-plus-operands.js

@@ -156,7 +156,7 @@ exports.default = (0, util_1.createRule)({
                     continue;
                 }
                 // RegExps also contain ts.TypeFlags.Any & ts.TypeFlags.Object
-                for (const subBaseType of tsutils.unionTypeParts(baseType)) {
+                for (const subBaseType of tsutils.unionConstituents(baseType)) {
                     const typeName = (0, util_1.getTypeName)(typeChecker, subBaseType);
                     if (typeName === 'RegExp'
                         ? !allowRegExp ||
@@ -221,11 +221,11 @@ exports.default = (0, util_1.createRule)({
 });
 function isDeeplyObjectType(type) {
     return type.isIntersection()
-        ? tsutils.intersectionTypeParts(type).every(tsutils.isObjectType)
-        : tsutils.unionTypeParts(type).every(tsutils.isObjectType);
+        ? tsutils.intersectionConstituents(type).every(tsutils.isObjectType)
+        : tsutils.unionConstituents(type).every(tsutils.isObjectType);
 }
 function isTypeFlagSetInUnion(type, flag) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(subType => tsutils.isTypeFlagSet(subType, flag));
 }

package/dist/rules/strict-boolean-expressions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAm/BG"}
+{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAq/BG"}

package/dist/rules/strict-boolean-expressions.js

@@ -237,7 +237,7 @@ exports.default = (0, util_1.createRule)({
                 return type;
             });
             const flattenTypes = [
-                ...new Set(returnTypes.flatMap(type => tsutils.unionTypeParts(type))),
+                ...new Set(returnTypes.flatMap(type => tsutils.unionConstituents(type))),
             ];
             const types = inspectVariantTypes(flattenTypes);
             const reportType = determineReportType(types);
@@ -774,7 +774,7 @@ exports.default = (0, util_1.createRule)({
          */
         function checkNode(node) {
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
-            const types = inspectVariantTypes(tsutils.unionTypeParts(type));
+            const types = inspectVariantTypes(tsutils.unionConstituents(type));
             const reportType = determineReportType(types);
             if (reportType != null) {
                 context.report({
@@ -799,7 +799,7 @@ exports.default = (0, util_1.createRule)({
             // If incoming type is either "true" or "false", there will be one type
             // object with intrinsicName set accordingly
             // If incoming type is boolean, there will be two type objects with
-            // intrinsicName set "true" and "false" each because of ts-api-utils.unionTypeParts()
+            // intrinsicName set "true" and "false" each because of ts-api-utils.unionConstituents()
             if (booleans.length === 1) {
                 variantTypes.add(tsutils.isTrueLiteralType(booleans[0]) ? 'truthy boolean' : 'boolean');
             }

package/dist/rules/switch-exhaustiveness-check.js

@@ -122,8 +122,8 @@ exports.default = (0, util_1.createRule)({
                 caseTypes.add(caseType);
             }
             const missingLiteralBranchTypes = [];
-            for (const unionPart of tsutils.unionTypeParts(discriminantType)) {
-                for (const intersectionPart of tsutils.intersectionTypeParts(unionPart)) {
+            for (const unionPart of tsutils.unionConstituents(discriminantType)) {
+                for (const intersectionPart of tsutils.intersectionConstituents(unionPart)) {
                     if (caseTypes.has(intersectionPart) ||
                         !isTypeLiteralLikeType(intersectionPart)) {
                         continue;
@@ -284,8 +284,8 @@ function isTypeLiteralLikeType(type) {
  */
 function doesTypeContainNonLiteralType(type) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(type => tsutils
-        .intersectionTypeParts(type)
+        .intersectionConstituents(type)
         .every(subType => !isTypeLiteralLikeType(subType)));
 }