@typescript-eslint/eslint-plugin 8.31.2-alpha.8 → 8.32.1-alpha.0

package/dist/rules/await-thenable.js

@@ -87,7 +87,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const hasAsyncIteratorSymbol = tsutils
-                    .unionTypeParts(type)
+                    .unionConstituents(type)
                     .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncIterator', checker) != null);
                 if (!hasAsyncIteratorSymbol) {
                     context.report({
@@ -118,7 +118,7 @@ exports.default = (0, util_1.createRule)({
                         continue;
                     }
                     const hasAsyncDisposeSymbol = tsutils
-                        .unionTypeParts(type)
+                        .unionConstituents(type)
                         .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncDispose', checker) != null);
                     if (!hasAsyncDisposeSymbol) {
                         context.report({

package/dist/rules/enum-utils/shared.js

@@ -66,7 +66,7 @@ function getBaseEnumType(typeChecker, type) {
  */
 function getEnumLiterals(type) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral));
 }
 /**

package/dist/rules/no-confusing-void-expression.js

@@ -327,7 +327,7 @@ exports.default = (0, util_1.createRule)({
             return callSignatures.some(signature => {
                 const returnType = signature.getReturnType();
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             });
         }
@@ -342,14 +342,14 @@ exports.default = (0, util_1.createRule)({
             if (functionTSNode.type) {
                 const returnType = checker.getTypeFromTypeNode(functionTSNode.type);
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             }
             if (ts.isExpression(functionTSNode)) {
                 const functionType = checker.getContextualType(functionTSNode);
                 if (functionType) {
                     return tsutils
-                        .unionTypeParts(functionType)
+                        .unionConstituents(functionType)
                         .some(isFunctionReturnTypeIncludesVoid);
                 }
             }

package/dist/rules/no-floating-promises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAkaG"}
+{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmBpD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAqZG"}

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

@@ -37,6 +37,7 @@ 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.';
 const messageBaseVoid = 'Promises must be awaited, end with a call to .catch, end with a call to .then with a rejection handler' +
     ' or be explicitly marked as ignored with the `void` operator.';
@@ -256,33 +257,20 @@ exports.default = (0, util_1.createRule)({
             if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
                 // If the outer expression is a call, a `.catch()` or `.then()` with
                 // rejection handler handles the promise.
-                const { callee } = node;
-                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    const methodName = (0, util_1.getStaticMemberAccessValue)(callee, context);
-                    const catchRejectionHandler = methodName === 'catch' && node.arguments.length >= 1
-                        ? node.arguments[0]
-                        : undefined;
-                    if (catchRejectionHandler) {
-                        if (isValidRejectionHandler(catchRejectionHandler)) {
+                const promiseHandlingMethodCall = (0, promiseUtils_1.parseCatchCall)(node, context) ?? (0, promiseUtils_1.parseThenCall)(node, context);
+                if (promiseHandlingMethodCall != null) {
+                    const onRejected = promiseHandlingMethodCall.onRejected;
+                    if (onRejected != null) {
+                        if (isValidRejectionHandler(onRejected)) {
                             return { isUnhandled: false };
                         }
                         return { isUnhandled: true, nonFunctionHandler: true };
                     }
-                    const thenRejectionHandler = methodName === 'then' && node.arguments.length >= 2
-                        ? node.arguments[1]
-                        : undefined;
-                    if (thenRejectionHandler) {
-                        if (isValidRejectionHandler(thenRejectionHandler)) {
-                            return { isUnhandled: false };
-                        }
-                        return { isUnhandled: true, nonFunctionHandler: true };
-                    }
-                    // `x.finally()` is transparent to resolution of the promise, so check `x`.
-                    // ("object" in this context is the `x` in `x.finally()`)
-                    const promiseFinallyObject = methodName === 'finally' ? callee.object : undefined;
-                    if (promiseFinallyObject) {
-                        return isUnhandledPromise(checker, promiseFinallyObject);
-                    }
+                    return { isUnhandled: true };
+                }
+                const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context);
+                if (promiseFinallyCall != null) {
+                    return isUnhandledPromise(checker, promiseFinallyCall.object);
                 }
                 // All other cases are unhandled.
                 return { isUnhandled: true };
@@ -309,7 +297,7 @@ exports.default = (0, util_1.createRule)({
         function isPromiseArray(node) {
             const type = checker.getTypeAtLocation(node);
             for (const ty of tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .map(t => checker.getApparentType(t))) {
                 if (checker.isArrayType(ty)) {
                     const arrayType = checker.getTypeArguments(ty)[0];
@@ -334,7 +322,7 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             // Otherwise, we always consider the built-in Promise to be Promise-like...
-            const typeParts = tsutils.unionTypeParts(checker.getApparentType(type));
+            const typeParts = tsutils.unionConstituents(checker.getApparentType(type));
             if (typeParts.some(typePart => (0, util_1.isBuiltinSymbolLike)(services.program, typePart, 'Promise'))) {
                 return true;
             }
@@ -363,7 +351,7 @@ exports.default = (0, util_1.createRule)({
     },
 });
 function hasMatchingSignature(type, matcher) {
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().some(matcher)) {
             return true;
         }
@@ -372,7 +360,7 @@ function hasMatchingSignature(type, matcher) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().length !== 0) {
             return true;
         }

package/dist/rules/no-meaningless-void-operator.js

@@ -79,7 +79,7 @@ exports.default = (0, util_1.createRule)({
                     ]);
                 };
                 const argType = services.getTypeAtLocation(node.argument);
-                const unionParts = tsutils.unionTypeParts(argType);
+                const unionParts = tsutils.unionConstituents(argType);
                 if (unionParts.every(part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
                     context.report({
                         node,

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

@@ -551,7 +551,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isSometimesThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         if (tsutils.isThenableType(checker, node, subType)) {
             return true;
         }
@@ -564,7 +564,7 @@ function isSometimesThenable(checker, node) {
 // branches is thenable.
 function isAlwaysThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         const thenProp = subType.getProperty('then');
         // If one of the alternates has no then property, it is not thenable in all
         // cases.
@@ -576,7 +576,7 @@ function isAlwaysThenable(checker, node) {
         // be of the right form to consider it thenable.
         const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
         let hasThenableSignature = false;
-        for (const subType of tsutils.unionTypeParts(thenType)) {
+        for (const subType of tsutils.unionConstituents(thenType)) {
             for (const signature of subType.getCallSignatures()) {
                 if (signature.parameters.length !== 0 &&
                     isFunctionParam(checker, signature.parameters[0], node)) {
@@ -602,7 +602,7 @@ function isAlwaysThenable(checker, node) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (subType.getCallSignatures().length !== 0) {
             return true;
         }
@@ -641,7 +641,7 @@ function voidFunctionArguments(checker, node) {
     const type = checker.getTypeAtLocation(node.expression);
     // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
     // See https://github.com/microsoft/TypeScript/issues/48077
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         // Standard function calls and `new` have two different types of signatures
         const signatures = ts.isCallExpression(node)
             ? subType.getCallSignatures()
@@ -698,7 +698,7 @@ function anySignatureIsThenableType(checker, node, type) {
  * @returns Whether type is a thenable-returning function.
  */
 function isThenableReturningFunctionType(checker, node, type) {
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (anySignatureIsThenableType(checker, node, subType)) {
             return true;
         }
@@ -710,7 +710,7 @@ function isThenableReturningFunctionType(checker, node, type) {
  */
 function isVoidReturningFunctionType(checker, node, type) {
     let hadVoidReturn = false;
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         for (const signature of subType.getCallSignatures()) {
             const returnType = signature.getReturnType();
             // If a certain positional argument accepts both thenable and void returns,
@@ -729,7 +729,7 @@ function isVoidReturningFunctionType(checker, node, type) {
 function returnsThenable(checker, node) {
     const type = checker.getApparentType(checker.getTypeAtLocation(node));
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(t => anySignatureIsThenableType(checker, node, t));
 }
 function getHeritageTypes(checker, tsNode) {

package/dist/rules/no-misused-spread.js

@@ -97,7 +97,7 @@ exports.default = (0, util_1.createRule)({
             }
         }
         function getMapSpreadSuggestions(node, type) {
-            const types = tsutils.unionTypeParts(type);
+            const types = tsutils.unionConstituents(type);
             if (types.some(t => !isMap(services.program, t))) {
                 return null;
             }
@@ -208,7 +208,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isIterable(type, checker) {
     return tsutils
-        .typeParts(type)
+        .typeConstituents(type)
         .some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker));
 }
 function isArray(checker, type) {

package/dist/rules/no-redundant-type-constituents.js

@@ -168,7 +168,7 @@ function unionTypePartsUnlessBoolean(type) {
         tsutils.isFalseLiteralType(type.types[0]) &&
         tsutils.isTrueLiteralType(type.types[1])
         ? [type]
-        : tsutils.unionTypeParts(type);
+        : tsutils.unionConstituents(type);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-redundant-type-constituents',

package/dist/rules/no-unnecessary-condition.js

@@ -44,14 +44,14 @@ function isNullishType(type) {
     return tsutils.isTypeFlagSet(type, nullishFlag);
 }
 function isAlwaysNullish(type) {
-    return tsutils.unionTypeParts(type).every(isNullishType);
+    return tsutils.unionConstituents(type).every(isNullishType);
 }
 /**
  * Note that this differs from {@link isNullableType} in that it doesn't consider
  * `any` or `unknown` to be nullable.
  */
 function isPossiblyNullish(type) {
-    return tsutils.unionTypeParts(type).some(isNullishType);
+    return tsutils.unionConstituents(type).some(isNullishType);
 }
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
@@ -198,13 +198,13 @@ exports.default = (0, util_1.createRule)({
         function nodeIsArrayType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isArrayType(part));
         }
         function nodeIsTupleType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isTupleType(part));
         }
         function isArrayIndexExpression(node) {
@@ -223,7 +223,7 @@ exports.default = (0, util_1.createRule)({
         //    `any` or `unknown` or a naked type variable
         function isConditionalAlwaysNecessary(type) {
             return tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .some(part => (0, util_1.isTypeAnyType)(part) ||
                 (0, util_1.isTypeUnknownType)(part) ||
                 (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable));

package/dist/rules/no-unnecessary-template-expression.js

@@ -77,7 +77,7 @@ exports.default = (0, util_1.createRule)({
             return isStringLike(type);
         }
         function isEnumMemberType(type) {
-            return tsutils.typeParts(type).some(t => {
+            return tsutils.typeConstituents(type).some(t => {
                 const symbol = t.getSymbol();
                 return !!(symbol?.valueDeclaration && ts.isEnumMember(symbol.valueDeclaration));
             });

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

@@ -171,10 +171,10 @@ exports.default = (0, util_1.createRule)({
                 (0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
                 tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
                 const uncastParts = tsutils
-                    .unionTypeParts(uncast)
+                    .unionConstituents(uncast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 const castParts = tsutils
-                    .unionTypeParts(cast)
+                    .unionConstituents(cast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 if (uncastParts.length !== castParts.length) {
                     return false;

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

@@ -1 +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,wBAoVG"}
+{"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

@@ -34,7 +34,7 @@ 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 tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
 exports.default = (0, util_1.createRule)({
@@ -57,7 +57,9 @@ exports.default = (0, util_1.createRule)({
     defaultOptions: [],
     create(context) {
         function doesUnderlyingTypeMatchFlag(type, typeFlag) {
-            return (0, ts_api_utils_1.unionTypeParts)(type).every(t => (0, util_1.isTypeFlagSet)(t, 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) {

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/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)));
 }

package/dist/rules/unbound-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA0KG"}
+{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA4KG"}

package/dist/rules/unbound-method.js

@@ -215,8 +215,8 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                     for (const intersectionPart of tsutils
-                        .unionTypeParts(services.getTypeAtLocation(node))
-                        .flatMap(unionPart => tsutils.intersectionTypeParts(unionPart))) {
+                        .unionConstituents(services.getTypeAtLocation(node))
+                        .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
                         const reported = checkIfMethodAndReport(property.key, intersectionPart.getProperty(property.key.name));
                         if (reported) {
                             break;

package/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -63,7 +63,7 @@ exports.default = (0, util_1.createRule)({
         const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context);
         const checker = program.getTypeChecker();
         function isFlaggableHandlerType(type) {
-            for (const unionPart of tsutils.unionTypeParts(type)) {
+            for (const unionPart of tsutils.unionConstituents(type)) {
                 const callSignatures = tsutils.getCallSignaturesOfType(unionPart);
                 if (callSignatures.length === 0) {
                     // Ignore any non-function components to the type. Those are not this rule's problem.

package/dist/util/isArrayMethodCallWithPredicate.js

@@ -58,7 +58,7 @@ function isArrayMethodCallWithPredicate(context, services, node) {
     const checker = services.program.getTypeChecker();
     const type = (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object);
     return tsutils
-        .unionTypeParts(type)
-        .flatMap(part => tsutils.intersectionTypeParts(part))
+        .unionConstituents(type)
+        .flatMap(part => tsutils.intersectionConstituents(part))
         .some(t => checker.isArrayType(t) || checker.isTupleType(t));
 }

package/dist/util/promiseUtils.d.ts

@@ -0,0 +1,28 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseThenCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onFulfilled?: TSESTree.Expression | undefined;
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseCatchCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseFinallyCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    object: TSESTree.Expression;
+    onFinally?: TSESTree.Expression | undefined;
+} | undefined;
+//# sourceMappingURL=promiseUtils.d.ts.map

package/dist/util/promiseUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/util/promiseUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAMtE;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9C,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAqCZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAuBZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;CAC7C,GACD,SAAS,CAsBZ"}

package/dist/util/promiseUtils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseThenCall = parseThenCall;
+exports.parseCatchCall = parseCatchCall;
+exports.parseFinallyCall = parseFinallyCall;
+const utils_1 = require("@typescript-eslint/utils");
+const misc_1 = require("./misc");
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+function parseThenCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'then') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                if (node.arguments.length >= 2) {
+                    if (node.arguments[1].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        return {
+                            object: node.callee.object,
+                            onFulfilled: node.arguments[0],
+                        };
+                    }
+                    return {
+                        object: node.callee.object,
+                        onFulfilled: node.arguments[0],
+                        onRejected: node.arguments[1],
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFulfilled: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+function parseCatchCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'catch') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onRejected: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+function parseFinallyCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'finally') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFinally: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}

package/dist/util/truthinessUtils.js

@@ -41,18 +41,18 @@ const getValueOfLiteralType_1 = require("./getValueOfLiteralType");
 const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
     (type.isLiteral() && !!(0, getValueOfLiteralType_1.getValueOfLiteralType)(type));
 const isPossiblyFalsy = (type) => tsutils
-    .unionTypeParts(type)
+    .unionConstituents(type)
     // Intersections like `string & {}` can also be possibly falsy,
     // requiring us to look into the intersection.
-    .flatMap(type => tsutils.intersectionTypeParts(type))
+    .flatMap(type => tsutils.intersectionConstituents(type))
     // PossiblyFalsy flag includes literal values, so exclude ones that
     // are definitely truthy
     .filter(t => !isTruthyLiteral(t))
     .some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
 exports.isPossiblyFalsy = isPossiblyFalsy;
 const isPossiblyTruthy = (type) => tsutils
-    .unionTypeParts(type)
-    .map(type => tsutils.intersectionTypeParts(type))
+    .unionConstituents(type)
+    .map(type => tsutils.intersectionConstituents(type))
     .some(intersectionParts => 
 // It is possible to define intersections that are always falsy,
 // like `"" & { __brand: string }`.

package/docs/rules/only-throw-error.mdx

@@ -123,6 +123,11 @@ interface Options {
     | string
   )[];
 
+  /**
+   * Whether to allow rethrowing caught values that are not `Error` objects.
+   */
+  allowRethrowing?: boolean;
+
   /**
    * Whether to always allow throwing values typed as `any`.
    */
@@ -136,6 +141,7 @@ interface Options {
 
 const defaultOptions: Options = {
   allow: [],
+  allowRethrowing: false,
   allowThrowingAny: true,
   allowThrowingUnknown: true,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.31.2-alpha.8",
+  "version": "8.32.1-alpha.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -50,50 +50,48 @@
   ],
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "clean": "tsc -b tsconfig.build.json --clean",
-    "postclean": "rimraf dist && rimraf coverage",
+    "clean": "rimraf dist/ coverage/",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
     "generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
     "generate:configs": "npx nx generate-configs repo",
     "lint": "npx nx lint",
     "test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
-    "test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts",
+    "test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts --no-coverage",
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.31.2-alpha.8",
-    "@typescript-eslint/type-utils": "8.31.2-alpha.8",
-    "@typescript-eslint/utils": "8.31.2-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.31.2-alpha.8",
+    "@typescript-eslint/scope-manager": "8.32.1-alpha.0",
+    "@typescript-eslint/type-utils": "8.32.1-alpha.0",
+    "@typescript-eslint/utils": "8.32.1-alpha.0",
+    "@typescript-eslint/visitor-keys": "8.32.1-alpha.0",
     "graphemer": "^1.4.0",
-    "ignore": "^5.3.1",
+    "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
-    "ts-api-utils": "^2.0.1"
+    "ts-api-utils": "^2.1.0"
   },
   "devDependencies": {
-    "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.31.2-alpha.8",
-    "@typescript-eslint/rule-tester": "8.31.2-alpha.8",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.32.1-alpha.0",
+    "@typescript-eslint/rule-tester": "8.32.1-alpha.0",
+    "@vitest/coverage-v8": "^3.1.2",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
     "eslint": "*",
     "json-schema": "*",
     "markdown-table": "^3.0.3",
-    "marked": "^5.1.2",
+    "marked": "^15.0.0",
     "mdast-util-from-markdown": "^2.0.0",
     "mdast-util-mdx": "^3.0.0",
     "micromark-extension-mdxjs": "^3.0.0",
     "prettier": "^3.2.5",
     "rimraf": "*",
-    "title-case": "^3.0.3",
+    "title-case": "^4.0.0",
     "tsx": "*",
     "typescript": "*",
     "unist-util-visit": "^5.0.0",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.2"
   },
   "peerDependencies": {
     "@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",