Spurious error when adding two list

[mishamsk]

Bug Report

Mypy reports Unsupported operand types for + when concatenating two lists, when the second operand is a subtype of the first.

This was previously mentioned in this comment in #5492

Below is a simple concise example

To Reproduce

class A:
 pass


class B(A):
 pass


def foo(a: list[A]) -> None:
 pass


l1: list[A] = [A(), B()]
l2: list[B] = [B()]
l3 = l1 + l2
foo(l2 + l1) # OK, no error
foo(l3) # also OK
foo(
 l1 + l2
) # ERROR: Unsupported operand types for + ("List[A]" and "List[B]") [operator]mypy(error)

gist link

Expected Behavior
No error on the last line

Actual Behavior
Reports spurious error

Your Environment

• Mypy version used: mypy 1.2.0
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): from pyproject.toml

ignore_missing_imports = true
show_column_numbers = true
warn_redundant_casts = true
warn_unused_ignores = true
warn_unused_configs = true
follow_imports = "normal"

plugins = ["pydantic.mypy"]

• Python version used: 3.10

[ikonst]

Smaller equivalent:

class A:
 pass

class B(A):
 pass

l1: list[A]
l2: list[B]
x: list[A] = l1 + l2

IIUC, the culprit is the two overloads:

class list(Generic[T], ...):
 @overload
 def __add__(self, __value: list[_T]) -> list[_T]: ...
 @overload
 def __add__(self, __value: list[_S]) -> list[_S | _T]: ...

The expression's expected type list[A] helps select the 1st overload and disqualify the 2nd overload. Maybe if mypy reduced A | B to A then it wouldn't disqualify. (Is doing that sound?)

[mishamsk]

@ikonst Thanks for shorter sample. I'd guess that reduction is not generally possible since list is invariant, and the sum of the operation should be treated as a union. Which btw reminds that in my example passing l3 to foo should have produced an error but somehow it didn't...

Surprised to learn that mypy uses the target var type to select appropriate overload. Didn't know that it works this way. Why so?

[ikonst]

I'd guess that reduction is not generally possible since list is invariant

It seems that if you type-annotate, then mypy would agree with you:

l1: list[A]
l2: list[B]
l3 = l1 + l2
reveal_type(l3) # builtins.list[Union[__main__.B, __main__.A]]
x: list[A] = l3

However, this won't work:

x: list[B] = l3

nor this:

x: list[A] = l2

so invariance is maintained, but list[A | B] to list[A] is apparently safe.