consistent-destructuring: Fix false positive for nested rest destructuring (#2894)

sindresorhus · web-flow · commit 1cddfb59c591 · 2026-03-05T20:11:24.000+07:00
diff --git a/rules/consistent-destructuring.js b/rules/consistent-destructuring.js
@@ -42,6 +42,46 @@ const getRootIdentifier = expression => {
 	return expression?.type === 'Identifier' ? expression : undefined;
 };
 
+const hasRestElement = pattern => {
+	switch (pattern?.type) {
+		case 'RestElement': {
+			return true;
+		}
+
+		case 'AssignmentPattern': {
+			return hasRestElement(pattern.left);
+		}
+
+		case 'ObjectPattern': {
+			return pattern.properties.some(property =>
+				hasRestElement(property.type === 'Property' ? property.value : property),
+			);
+		}
+
+		case 'ArrayPattern': {
+			return pattern.elements.some(element =>
+				hasRestElement(element),
+			);
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isIdentifierProperty = property =>
+	property.type === 'Property'
+	&& property.key.type === 'Identifier';
+
+const isMemberDestructuredInNestedPatternWithRest = (objectPattern, memberName) =>
+	objectPattern.properties.some(property =>
+		isIdentifierProperty(property)
+		&& property.key.name === memberName
+		&& property.value.type !== 'Identifier'
+		&& hasRestElement(property.value),
+	);
+
 const isRootVariableReassigned = (declaration, memberExpressionNode, memberScope, sourceCode) => {
 	if (!declaration.rootVariable) {
 		return false;
@@ -135,24 +175,31 @@ const create = context => {
 			return;
 		}
 
-		const destructurings = objectPattern.properties.filter(property =>
-			property.type === 'Property'
-			&& property.key.type === 'Identifier'
+		const member = sourceCode.getText(node.property);
+
+		// If the member is already destructured via a nested pattern with rest,
+		// don't suggest adding a separate top-level destructuring for the same member.
+		const memberDestructuredInNestedPattern = isMemberDestructuredInNestedPatternWithRest(objectPattern, member);
+
+		const destructuredProperties = objectPattern.properties.filter(property =>
+			isIdentifierProperty(property)
 			&& property.value.type === 'Identifier',
 		);
-		const lastProperty = objectPattern.properties.at(-1);
-
-		const hasRest = lastProperty && lastProperty.type === 'RestElement';
 
+		const lastProperty = objectPattern.properties.at(-1);
+		const hasRest = lastProperty?.type === 'RestElement';
 		const expression = sourceCode.getText(node);
-		const member = sourceCode.getText(node.property);
 
 		// Member might already be destructured
-		const destructuredMember = destructurings.find(property =>
+		const destructuredMember = destructuredProperties.find(property =>
 			property.key.name === member,
 		);
 
 		if (!destructuredMember) {
+			if (memberDestructuredInNestedPattern) {
+				return;
+			}
+
 			// Don't destructure additional members when rest is used
 			if (hasRest) {
 				return;
diff --git a/test/consistent-destructuring.js b/test/consistent-destructuring.js
@@ -165,6 +165,46 @@ test({
 			} = foo;
 			console.log(b.a);
 		`,
+		outdent`
+			const t = {a: {b: {c: 0, d: 1, e: 2}}};
+			const {
+				a: {
+					b: {c, ...other}
+				}
+			} = t;
+			const tt = {...t, a: {...t.a, b: other}};
+		`,
+		outdent`
+			const t = {
+				get a() {
+					return {b: {c: 0, d: 1, e: 2}};
+				}
+			};
+			const {
+				a: {
+					b: {c, ...other}
+				}
+			} = t;
+			console.log(t.a, other);
+		`,
+		outdent`
+			const {
+				a: {
+					b,
+					...other
+				} = fallback
+			} = foo;
+			console.log(foo.a, b, other);
+		`,
+		outdent`
+			const {
+				a: [
+					b,
+					...other
+				]
+			} = foo;
+			console.log(foo.a, b, other);
+		`,
 		outdent`
 			function bar() {
 				const {a} = foo;
@@ -372,6 +412,28 @@ test({
 				console.log(a);
 			`],
 		}),
+		invalidTestCase({
+			code: outdent`
+				const {
+					a: {
+						b,
+						...other
+					},
+					a
+				} = foo;
+				console.log(foo.a);
+			`,
+			suggestions: [outdent`
+				const {
+					a: {
+						b,
+						...other
+					},
+					a
+				} = foo;
+				console.log(a);
+			`],
+		}),
 		invalidTestCase({
 			code: outdent`
 				const {
