Literal types are widened for not-annotated instance variables

[twoertwein]

Describe the bug
When assigning a Literal-annotated variable as an not-annotated instance variable, pyright widens the literal type but only when the variable is accessed in a different method.

To Reproduce

# pyright: strict
from typing import Literal

SomeOption = Literal["a", "b", "c"]

def foo(x: SomeOption):
    ...

class Test:
    def __init__(self, x: SomeOption):
        self.x = x
        foo(self.x)  # passes

    def test(self):
        foo(self.x)  # errors

error: Argument of type "str" cannot be assigned to parameter "x" of type "SomeOption" in function "foo"
  Type "str" cannot be assigned to type "SomeOption"
    "str" cannot be assigned to type "Literal['a']"
    "str" cannot be assigned to type "Literal['b']"
    "str" cannot be assigned to type "Literal['c']" (reportGeneralTypeIssues)

with pyright 1.1.232

[erictraut]

This is the intended behavior. You have not provided a type declaration for the instance variable x, so its type is inferred based on assigned values. When a literal value is used for inference, its type is widened to the corresponding non-literal type. As with most type inference behaviors, there's no "right answer", but we've found over the past couple of years that the current behavior is better than the alternatives. Changing the behavior would be very disruptive for existing pyright users, so we're unlikely to change it at this point.

For full details of the type inference in pyright, refer to this documentation.

If your intent is for the instance variable x to be limited to just three literal values, you can simply add a type declaration.

self.x: SomeOption = x