Preserve Named Properties when Merging Tuple Types

[BribeFromTheHive]

Suggestion

🔍 Search Terms

• Named properties in merged tuple types
• Rest parameters with named tuple properties
• Merge tuple types while preserving named properties

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Add the ability to merge tuple types while preserving the named properties of their elements.

📃 Motivating Example

Currently, when tuple types with named properties are merged using the spread operator ..., TypeScript loses the named properties of the tuple elements. This makes it difficult to maintain named parameter hints in function signatures when using rest parameters with merged tuple types.

💻 Use Cases

Consider the following example:

type SimpleArgs = [a: number, b: string];

type MergedArgs = [...SimpleArgs, c: boolean];

function exampleFunction(...args: MergedArgs) {
  const [a, b, c] = args;
  // Do stuff with a,b,c
}

exampleFunction(1, 'hello', true);

In this scenario, the named properties a, b, and c are lost when the tuple types are merged into MergedArgs. As a result, the parameter hints for exampleFunction do not show the named properties when mousing over the function signature.

It would be beneficial to have a way to merge tuple types that preserves the named properties of their elements, improving the developer experience when working with rest parameters in function signatures.

[RyanCavanaugh]

Currently, when calling the blah function, the editor hints display the args rest parameter, but they do not display the named parameter hints from the tuple type (e.g., a: someType, b: anotherType, etc.).

That's not what I'm seeing?

[BribeFromTheHive]

Hi @RyanCavanaugh,

Thanks for getting back to me on this so quickly.

I'd like to apologize that my initial feature request was a bit unclear. After seeing your reply, I realized that what I was trying to achieve was a bit more nuanced than I initially explained. So, I've gone ahead and updated the request with a clearer description/title and some practical use cases.

Thanks for your patience!

• Luke

[fatcerberus]

With the updated example in the OP, this looks like a duplicate of #52853

[BribeFromTheHive]

Correct! They are one and the same issue. Thanks for that!