Wrong overload for `str.join` / assignability to `Iterable[_]`

[sharkdp]

The return type of str.join should be str here, not LiteralString:

from typing import reveal_type

def _(pair: tuple[str, str]):
    reveal_type(", ".join(pair))  # ty: LiteralString

Seems related to the fact that we seem to think that tuple[str, str] or Iterable[str] is assignable to Iterable[LiteralString]:

from typing import LiteralString, Iterable

def _(iterable: Iterable[str]):
    x: Iterable[LiteralString] = iterable  # this should be an error

https://play.ty.dev/b1a1e84a-6cb9-4b46-89aa-3567a830bad0

[dhruvmanila]

The first example is probably related to #665.

[carljm]

And I suspect the second part is because Iterable is a protocol, and currently our protocol support only checks member existence, not member type; @AlexWaygood is working on this.

[karlicoss]

I have the following example where I'd expect type error, I assume it's the same issue? https://play.ty.dev/5294987b-6776-4cde-9844-bf45e510f59d

from collections.abc import Iterator, Sequence

def gen() -> Iterator[str]:
    yield 123  # expect type error here!

def seq() -> Sequence[str]:
    return [123]  # expect type error here!


a: Iterator[int] = gen()  # expect type error here!

## the types themselves seem to be inferred correctly
reveal_type(gen)
reveal_type(seq())

[jelle-openai]

I'd suspect that's different. The return [123] is because ty isn't inferring precise types for list literals; there are open issues about that. The yield 123 likely means that ty isn't type-checking yields in generators yet. I don't see an open issue about that but experimenting in the playground gives some TODO types.