Assigning to a slice of a list fails to retain literal values

[MageJohn]

Describe the bug

Assigning to a slice of a list fails to retain literal values

Code or Screenshots

Code sample in pyright playground

from typing import Literal

type Tag = Literal["A", "B"]

l: list[tuple[Tag, str]] = [
    ("A", "foo"),
    ("B", "bar"),
    ("A", "basz")
]

l[0] = ("B", "foo") # works fine

l[0:0] = [("B", "foo")] # fails

VS Code extension or command-line

Are you running pyright as a VS Code extension, a language server in another editor, integrated into Pylance, or the command-line tool? Which version?

I'm running it as a VS Code extension (the code package on Arch Linux). The version is v1.1.390

[erictraut]

The observed behavior is a consequence of pyright's inference behavior for tuples. It retains literal values for "bare" tuple expressions but does not for tuple expressions that are nested within another container like a list expression.

Normally, bidirectional type inference would help here, but pyright's bidirectional inference logic doesn't currently handle overloaded __setitem__ methods like the one found in the list class.

Adding bidirectional type inference support for overloaded __setitem__ will be a moderate amount of work, but I think it's a reasonable enhancement request.

In the meantime, you can work around this limitation by using a temporary variable with an explicit type declaration.

    temp: list[tuple[Tag, str]] = [("B", "foo")]
    l[0:0] = temp

[MageJohn]

Thanks for the quick response, and the workaround!

[aminakhanum44]

from typing import Literal, cast

Define the literal type

Tag = Literal["A", "B"]

Define the list with the correct type annotation

l: list[tuple[Tag, str]] = [
("A", "foo"),
("B", "bar"),
("A", "basz"),
]

Assign to an element (this works fine)

l[0] = ("B", "foo")

Workaround 1: Explicitly annotate the new items being inserted

new_items: list[tuple[Tag, str]] = [("B", "foo")]
l[0:0] = new_items

Workaround 2: Use cast to explicitly set the type for the assigned values

l[0:0] = [cast(tuple[Tag, str], ("A", "baz"))]

Verify that the list retains the expected type

print(l) # Output: [('A', 'baz'), ('B', 'foo'), ('A', 'foo'), ('B', 'bar'), ('A', 'basz')]