Annotated assignments of non-name targets are not checked

[mtshiba]

Summary

The following code passes without any errors.

l = []
l[0]: int = "foo"

class C:
    declared: int

c = C()
c.unresolved: int = "foo"
c.declared: str = "foo"

I thought these should be reported as type errors, but it seems that mypy and pyright treat such annotated assignments as "semantically invalid" and report errors without type checking.
In any case, since the current version of ty does not report any problems for this, some kind of fix should be made. In particular, the lack of checking for attribute existence (c.unresolved) is an obvious bug that should be fixed.

see also: microsoft/pylance-release#537

Version

ty 0.0.1a6 (ruff@83a036960)

[carljm]

I think annotated assignments of non-Name targets should be treated as inherently semantically invalid and always error, like mypy and pyright do.

Ideally, in addition to emitting the error that the annotation is invalid, we would just then ignore the annotation, and check the assignment as if it were an un-annotated assignment.

[jelle-openai]

Note both mypy and pyright accept annotations on attribute assignments of self, like this:

from typing import Any
class X:
    def __init__(self, x: Any):
        self.x: int = x
        
    def method(self) -> None:
        reveal_type(self.x) # int

[carljm]

Yes, thanks: annotated assignments to attributes of self should be accepted.

[sharkdp]

FWIW, pyright also supports this (mypy emits an error on the attribute assignment):

class C:
    @classmethod
    def f(cls) -> None:
        cls.x: int = 1


reveal_type(C.x)  # int

[AlexWaygood]

One related thing that does seem to me to be buggy is that we do not currently infer that Foo has an instance attribute x for something like this:

class Foo:
    def __init__(self):
        self.x: int

f = Foo()

# Type `Foo` has no attribute `x` (unresolved-attribute)
reveal_type(f.x)  # revealed: Unknown

If you're not actually assigning to self.x, I don't really know why you'd do this rather than annotating it in the class body, which seems more explicit:

class Foo:
    x: int

But popular libraries such as pytest do this, it appears to be supported by mypy and pyright, and it doesn't seem any less safe than annotating an instance attribute in the class body without assigning to it. So I think we should add support for this pattern.

Our lack of support for this pattern appears to be the cause of several new false positives in the mypy_primer report in astral-sh/ruff#18041 (comment).

[carljm]

One related thing that does seem to me to be buggy

This is related, but to me seems separate enough from the title of this issue to deserve its own issue. I created #590

I suspect this might be pretty easy to fix (and thus could get the "help wanted" label), but I'm not familiar enough with the details of our instance attribute machinery to be confident of that.