type inferance from await asyncio.gather() with 6 elements no longer works

Bug Report

mypy doesn't seem to properly infer types when unpacking the results of an asyncio.gather() that has at least 6 elements.

This leads to the unpacked variables getting assigned the object type, and then future uses of the variable cause typing issues.

To Reproduce

import asyncio
import datetime

async def get_str_value() -> str:
    await asyncio.sleep(1)

    return 'value'

async def get_datetime_value() -> datetime.datetime:
    await asyncio.sleep(2)

    return datetime.datetime.now()

async def run() -> None:

    (str1_value,
     str2_value,
     str3_value,
     datetime1_value,
     str4_value,
     str5_value,
     datetime2_value) = reveal_type(await asyncio.gather(get_str_value(),
                                                         get_str_value(),
                                                         get_str_value(),
                                                         get_datetime_value(),
                                                         get_str_value(),
                                                         get_str_value(),
                                                         get_datetime_value()))

    reveal_type(str1_value)
    reveal_type(datetime1_value)

    print(f"str={str1_value}, date={datetime1_value}")

asyncio.run(run())

Expected Behavior

mypy should be able to infer the appropriate type of the values from the gathered list. From searching, it looks like this might be a typeshed issue, or it might be something in mypy itself. It is unclear what can be done here.

Actual Behavior

mypy infers the return of the await as a list, and then assigns the object type to each of the variables. This results in cascading type errors as other code assumes those variables would be the appropriate type.

If you only have 5 values, then this correctly unpacks the tuple into the specific variables. But as soon as you gather 6 items it breaks.

asyncio-gather-test.py:21: note: Revealed type is "tuple[builtins.str, builtins.str, builtins.str, datetime.datetime, builtins.str, builtins.str]"
asyncio-gather-test.py:29: note: Revealed type is "builtins.str"
asyncio-gather-test.py:30: note: Revealed type is "datetime.datetime"

Your Environment

• Mypy version used: 1.9, I also tried a development build
• Mypy command-line flags: mypy
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: 3.12.2

I'm really not sure what a good workaround in my own code would be here. For now I've taken to using asserts to check the types, which works ok, but is verbose.

Start by reproducing the supplied asyncio.gather example, comparing five and six or more arguments and checking the reveal_type output. Determine whether the fix belongs in typeshed or mypy, and consider it done when the heterogeneous results retain their individual types for the reported seven-element call without cascading errors.