Use join to calculate better fallback for tuples

[JukkaL]

Currently the fallback of named tuple types and tuples is Tuple[Any, ...] but we could use join of items to get a more precise fallback type after #3560 has been merged.

Pointers:

• Update tuple_type in mypy.typeanal.
• Update build_namedtuple_typeinfo in mypy.semanal.
• Use the fixups to be introduced in Fix crash with forward reference in TypedDict #3560 (the PR has not been merged as of writing this).

[gvanrossum]

Remind me where the fallback type is used? I already think we're being too strict in some cases, e.g.

a = (1, 2)
b = a + ('', '')

give an error on the second line Unsupported operand types for + ("Tuple[int, int]" and "Tuple[str, str]") but I think it should just make the type of b: Tuple[int, int, str, str].

Also, this is still an error:

from typing import Tuple
a = (1, 2)
b = a + ('', '')  # type: Tuple[int, int, str, str]

There are actually two errors even:

__tmp__.py:3: error: Incompatible types in assignment (expression has type Tuple[int, ...], variable has type "Tuple[int, int, str, str]")
__tmp__.py:3: error: Unsupported operand types for + ("Tuple[int, int]" and "Tuple[str, str]")

[ilevkivskyi]

Remind me where the fallback type is used?

The most important places are probably in subtypes.py where subtyping relationships between TupleTypes and Instances are decided (e.g. for named tuples), and in checkmember.py for look-up of attributes on tuples (like __add__ in your example).

We of course could be more flexible with tuples, and there are issues for this like #224, this could be done by special-casing. A more "broad" solution for such situations may be variadic generics. Anyway, both these ways are mostly unrelated to the joins in fallbacks.

[JukkaL]

The fallback Any item type seems to used at least for multiplication and addition. It doesn't affect subtyping universally, since tuple subtyping has been special cased, but it might affect some special cases. Other operations might not be affected since they are special cased.

[ilevkivskyi]

Hm, actually this issue was fixed by #3952 only partially: the first bullet in the first message is still missing. Precise fallbacks are generated only for named tuples, not for "normal" tuples, the latter still have Any in fallback.

[ilevkivskyi]

Just a note (mostly to myself), when updating the fallbacks in patches we should take care that it doesn't interfere with subclassing "normal" tuples:

class B:
    attr: int

class C(B, Tuple[int, str]):
    label: str

(The patch is therefore probably should be made in semananl.py, where we know the context for TupleType, not in typeanal.py.)

[ilevkivskyi]

Adding the patch is easy here, but this reveals several other errors/bugs, so it is not easy after all. Also tuple[Any] fallback is probably fine for now.

[ilevkivskyi]

This was essentially fixed by #6442