Fix excess property checking when accessing last tuple element in destructuring

Co-authored-by: RyanCavanaugh <[email protected]>

Author: Copilot

src/compiler/checker.ts

@@ -31857,10 +31857,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) ||
             parent.kind !== SyntaxKind.BindingElement && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? CheckMode.RestBindingElement : CheckMode.Normal);
         if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name)) return undefined;
-        if (parent.name.kind === SyntaxKind.ArrayBindingPattern) {
-            const index = indexOfNode(declaration.parent.elements, declaration);
-            if (index < 0) return undefined;
-            return getContextualTypeForElementExpression(parentType, index, declaration.parent.elements.length);
+        if (parent.name.kind === SyntaxKind.ArrayBindingPattern) {
+            const index = indexOfNode(declaration.parent.elements, declaration);
+            if (index < 0) return undefined;
+            return getContextualTypeForElementExpression(parentType, index, declaration.parent.elements.length);
         }
         const nameType = getLiteralTypeFromPropertyName(name);
         if (isTypeUsableAsPropertyName(nameType)) {
@@ -32391,25 +32391,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return { first, last };
     }
 
-    function getContextualTypeForElementExpression(type: Type | undefined, index: number, length?: number, firstSpreadIndex?: number, lastSpreadIndex?: number): Type | undefined {
-        return type && mapType(type, t => {
-            if (isTupleType(t)) {
-                // If index is before any spread element and within the fixed part of the contextual tuple type, return
-                // the type of the contextual tuple element.
-                if ((firstSpreadIndex === undefined || index < firstSpreadIndex) && index < t.target.fixedLength) {
-                    return removeMissingType(getTypeArguments(t)[index], !!(t.target.elementFlags[index] && ElementFlags.Optional));
-                }
-                // When the length is known and the index is after all spread elements we compute the offset from the element
-                // to the end and the number of ending fixed elements in the contextual tuple type.
-                const offset = length !== undefined && (lastSpreadIndex === undefined || index > lastSpreadIndex) ? length - index : 0;
-                const fixedEndLength = offset > 0 && (t.target.combinedFlags & ElementFlags.Variable) ? getEndElementCount(t.target, ElementFlags.Fixed) : 0;
-                // If the offset is within the ending fixed part of the contextual tuple type, return the type of the contextual
-                // tuple element.
-                if (offset > 0 && offset <= fixedEndLength) {
-                    return getTypeArguments(t)[getTypeReferenceArity(t) - offset];
-                }
-                // Return a union of the possible contextual element types with no subtype reduction.
-                return getElementTypeOfSliceOfTupleType(t, firstSpreadIndex === undefined ? t.target.fixedLength : Math.min(t.target.fixedLength, firstSpreadIndex), length === undefined || lastSpreadIndex === undefined ? fixedEndLength : Math.min(fixedEndLength, length - lastSpreadIndex), /*writing*/ false, /*noReductions*/ true);
+    function getContextualTypeForElementExpression(type: Type | undefined, index: number, length?: number, firstSpreadIndex?: number, lastSpreadIndex?: number): Type | undefined {
+        return type && mapType(type, t => {
+            if (isTupleType(t)) {
+                // If index is before any spread element and within the fixed part of the contextual tuple type, return
+                // the type of the contextual tuple element.
+                if ((firstSpreadIndex === undefined || index < firstSpreadIndex) && index < t.target.fixedLength) {
+                    return removeMissingType(getTypeArguments(t)[index], !!(t.target.elementFlags[index] && ElementFlags.Optional));
+                }
+                // When the length is known and the index is after all spread elements we compute the offset from the element
+                // to the end and the number of ending fixed elements in the contextual tuple type.
+                const offset = length !== undefined && (lastSpreadIndex === undefined || index > lastSpreadIndex) ? length - index : 0;
+                const fixedEndLength = offset > 0 && (t.target.combinedFlags & ElementFlags.Variable) ? getEndElementCount(t.target, ElementFlags.Fixed) : 0;
+                // If the offset is within the ending fixed part of the contextual tuple type, return the type of the contextual
+                // tuple element.
+                if (offset > 0 && offset <= fixedEndLength) {
+                    return getTypeArguments(t)[getTypeReferenceArity(t) - offset];
+                }
+                // Return a union of the possible contextual element types with no subtype reduction.
+                return getElementTypeOfSliceOfTupleType(t, firstSpreadIndex === undefined ? t.target.fixedLength : Math.min(t.target.fixedLength, firstSpreadIndex), length === undefined || lastSpreadIndex === undefined ? fixedEndLength : Math.min(fixedEndLength, length - lastSpreadIndex), /*writing*/ false, /*noReductions*/ true);
             }
             // If element index is known and a contextual property with that name exists, return it. Otherwise return the
             // iterated or element type of the contextual type.
@@ -36027,6 +36027,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return skipOuterExpressions(argument, flags);
     }
 
+    function isCallInLastTupleElementDestructuring(node: CallLikeExpression): boolean {
+        // Check if this call expression is used as initializer in a variable declaration with array destructuring
+        const parent = node.parent;
+        if (parent && isVariableDeclaration(parent) && parent.initializer === node && isArrayBindingPattern(parent.name)) {
+            const elements = parent.name.elements;
+            // Check if the destructuring pattern accesses the last element
+            // (i.e., the last non-omitted element is at the end of the pattern)
+            for (let i = elements.length - 1; i >= 0; i--) {
+                if (!isOmittedExpression(elements[i])) {
+                    // If the last non-omitted element is at the last position, it's accessing the last tuple element
+                    return i === elements.length - 1;
+                }
+            }
+        }
+        return false;
+    }
+
     function getSignatureApplicabilityError(
         node: CallLikeExpression,
         args: readonly Expression[],
@@ -36069,7 +36086,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // If one or more arguments are still excluded (as indicated by CheckMode.SkipContextSensitive),
                 // we obtain the regular type of any object literal arguments because we may not have inferred complete
                 // parameter types yet and therefore excess property checks may yield false positives (see #17041).
-                const checkArgType = checkMode & CheckMode.SkipContextSensitive ? getRegularTypeOfObjectLiteral(argType) : argType;
+                // Also skip fresh literal checking when the call is in last tuple element destructuring context
+                // to prevent incorrect excess property errors (see #41548).
+                const shouldSkipFreshness = (checkMode & CheckMode.SkipContextSensitive) ||
+                    (isCallExpression(node) && isCallInLastTupleElementDestructuring(node));
+                const checkArgType = shouldSkipFreshness ? getRegularTypeOfObjectLiteral(argType) : argType;
                 const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
                 if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? effectiveCheckArgumentNode : undefined, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
                     Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");

tests/baselines/reference/lastTupleElementDestructuring.errors.txt

@@ -0,0 +1,52 @@
+lastTupleElementDestructuring.ts(18,27): error TS2322: Type '"c"' is not assignable to type '"a" | "b"'.
+lastTupleElementDestructuring.ts(19,24): error TS2345: Argument of type '{ notDataType: string; }' is not assignable to parameter of type '{ dataType: "a" | "b"; }'.
+  Property 'dataType' is missing in type '{ notDataType: string; }' but required in type '{ dataType: "a" | "b"; }'.
+lastTupleElementDestructuring.ts(33,34): error TS2345: Argument of type '{ optional: number; }' is not assignable to parameter of type 'Config'.
+  Property 'required' is missing in type '{ optional: number; }' but required in type 'Config'.
+
+
+==== lastTupleElementDestructuring.ts (3 errors) ====
+    // Test for fixing excess property checking when accessing last tuple element in destructuring
+    // Fixes https://github.com/microsoft/TypeScript/issues/41548
+    
+    declare function foo<T extends { dataType: 'a' | 'b' }>(template: T): [T, any, any];
+    declare function bar<T extends { dataType: 'a' | 'b' }>(template: T): [T, any, any, any];
+    
+    // Cases that should NOT error after fix (accessing last element)
+    const [, , last1] = foo({ dataType: 'a', day: 0 });
+    const [,,last2] = foo({ dataType: 'a', day: 0 });
+    const [,,,last3] = bar({ dataType: 'a', day: 0 });
+    
+    // Cases that already worked (not accessing last element)
+    const [, mid1, ] = foo({ dataType: 'a', day: 0 });
+    const [first1, , ] = foo({ dataType: 'a', day: 0 });
+    const [,,third,] = bar({ dataType: 'a', day: 0 });
+    
+    // Legitimate errors should still be caught
+    const [, , last4] = foo({ dataType: 'c' }); // Error: 'c' not assignable to 'a' | 'b'
+                              ~~~~~~~~
+!!! error TS2322: Type '"c"' is not assignable to type '"a" | "b"'.
+!!! related TS6500 lastTupleElementDestructuring.ts:4:34: The expected type comes from property 'dataType' which is declared here on type '{ dataType: "a" | "b"; }'
+    const [,,,last5] = bar({ notDataType: 'a' }); // Error: missing required property 'dataType'
+                           ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ notDataType: string; }' is not assignable to parameter of type '{ dataType: "a" | "b"; }'.
+!!! error TS2345:   Property 'dataType' is missing in type '{ notDataType: string; }' but required in type '{ dataType: "a" | "b"; }'.
+!!! related TS2728 lastTupleElementDestructuring.ts:5:34: 'dataType' is declared here.
+    
+    // Test with more complex object properties
+    interface Config {
+        required: string;
+        optional?: number;
+    }
+    
+    declare function withConfig<T extends Config>(template: T): [T, string];
+    
+    // Should work - accessing last element with extra property
+    const [,configStr] = withConfig({ required: 'test', extra: 'should work' });
+    
+    // Should still error - missing required property
+    const [,configStr2] = withConfig({ optional: 42 }); // Error: missing 'required'
+                                     ~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ optional: number; }' is not assignable to parameter of type 'Config'.
+!!! error TS2345:   Property 'required' is missing in type '{ optional: number; }' but required in type 'Config'.
+!!! related TS2728 lastTupleElementDestructuring.ts:23:5: 'required' is declared here.

tests/baselines/reference/lastTupleElementDestructuring.js

@@ -0,0 +1,55 @@
+//// [tests/cases/compiler/lastTupleElementDestructuring.ts] ////
+
+//// [lastTupleElementDestructuring.ts]
+// Test for fixing excess property checking when accessing last tuple element in destructuring
+// Fixes https://github.com/microsoft/TypeScript/issues/41548
+
+declare function foo<T extends { dataType: 'a' | 'b' }>(template: T): [T, any, any];
+declare function bar<T extends { dataType: 'a' | 'b' }>(template: T): [T, any, any, any];
+
+// Cases that should NOT error after fix (accessing last element)
+const [, , last1] = foo({ dataType: 'a', day: 0 });
+const [,,last2] = foo({ dataType: 'a', day: 0 });
+const [,,,last3] = bar({ dataType: 'a', day: 0 });
+
+// Cases that already worked (not accessing last element)
+const [, mid1, ] = foo({ dataType: 'a', day: 0 });
+const [first1, , ] = foo({ dataType: 'a', day: 0 });
+const [,,third,] = bar({ dataType: 'a', day: 0 });
+
+// Legitimate errors should still be caught
+const [, , last4] = foo({ dataType: 'c' }); // Error: 'c' not assignable to 'a' | 'b'
+const [,,,last5] = bar({ notDataType: 'a' }); // Error: missing required property 'dataType'
+
+// Test with more complex object properties
+interface Config {
+    required: string;
+    optional?: number;
+}
+
+declare function withConfig<T extends Config>(template: T): [T, string];
+
+// Should work - accessing last element with extra property
+const [,configStr] = withConfig({ required: 'test', extra: 'should work' });
+
+// Should still error - missing required property
+const [,configStr2] = withConfig({ optional: 42 }); // Error: missing 'required'
+
+//// [lastTupleElementDestructuring.js]
+// Test for fixing excess property checking when accessing last tuple element in destructuring
+// Fixes https://github.com/microsoft/TypeScript/issues/41548
+// Cases that should NOT error after fix (accessing last element)
+var _a = foo({ dataType: 'a', day: 0 }), last1 = _a[2];
+var _b = foo({ dataType: 'a', day: 0 }), last2 = _b[2];
+var _c = bar({ dataType: 'a', day: 0 }), last3 = _c[3];
+// Cases that already worked (not accessing last element)
+var _d = foo({ dataType: 'a', day: 0 }), mid1 = _d[1];
+var _e = foo({ dataType: 'a', day: 0 }), first1 = _e[0];
+var _f = bar({ dataType: 'a', day: 0 }), third = _f[2];
+// Legitimate errors should still be caught
+var _g = foo({ dataType: 'c' }), last4 = _g[2]; // Error: 'c' not assignable to 'a' | 'b'
+var _h = bar({ notDataType: 'a' }), last5 = _h[3]; // Error: missing required property 'dataType'
+// Should work - accessing last element with extra property
+var _j = withConfig({ required: 'test', extra: 'should work' }), configStr = _j[1];
+// Should still error - missing required property
+var _k = withConfig({ optional: 42 }), configStr2 = _k[1]; // Error: missing 'required'