Add new flag for warning about instantiating classes with declared but uninitialized attributes

[tmke8]

Fixes #4426
(also related: #4019)

Issue #4426 proposed prohibiting abstract attributes. I took a stab at implementing this, but I added it behind a new flag.
The new flag makes mypy complain when variables are declared in a class (with a type annotation) but never initialized. Other type checkers have similar features: for pyright, it's behind the flag reportUninitializedInstanceVariable and pyre does this by default.

One problem is that there are many ways to go about this. I think there are 4 natural places where the warning could be raised:

class A:  # option A: complain here
    x: int
    y: str

    def __init__(self) -> None:  # option B: complain here
        self.x = 0

a = A()  # option C: complain here
a.y  # option D: complain here

I went with option C because 1) it was easier to implement because I could re-use the code that deals with Protocol attributes; 2) it's more flexible than option A and B while easier to keep track of than option D; and 3) it fits with other reporting patterns in mypy, which is to report abstract status at the point of instantiation.

Option C is more flexible because the following code is allowed:

from abc import ABC
class A(ABC):  # (this would have worked without the ABC as well though)
    x: str
class B(A):
    def __init__(self) -> None:
        self.x = "foo"
B()  # OK

class C:
    x: int
    def f(self) -> None:  # note that this isn't __init__
        self.x = 0
C()  # also OK

Though I'll note that pyright and pyre went with option A (suppressing the error for abstract classes).

Because I repurposed the Protocol attribute code, the error messages aren't ideal yet, but I can still change that if the general idea of the PR is approved of. Currently, if --warn-uninitialized-attributes is turned on, then the error message for this code

class A:
    x: int
a = A()

is:

error: Cannot instantiate abstract class "A" with abstract attribute "x"

The name of the flag is --warn-uninitialized-attributes, but tell me if it should be something else.

By the way, if I turn on this flag for the self check in the tests, then this is the result (8 errors).

mypy/nodes.py:399: error: Cannot instantiate abstract class "MypyFile" with abstract attributes "_fullname" and "names"  [abstract]                                                                                            
            tree = MypyFile([], [])                                                                                                                                                                                            
                   ^~~~~~~~~~~~~~~~                                                                                                                                                                                            
mypy/treetransform.py:149: error: Cannot instantiate abstract class "MypyFile" with abstract attributes "_fullname" and "names"  [abstract]                                                                                    
            new = MypyFile(self.statements(node.defs), [], node.is_bom, ignored_lines=ignored_lines)                                                                                                                           
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                                                                                                                           
mypy/fastparse.py:303: error: Cannot instantiate abstract class "MypyFile" with abstract attributes "_fullname" and "names"  [abstract]                                                                                        
            tree = MypyFile([], [], False, {})                                                                                                                                                                                
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~                                                                                                                                                                                
mypy/fastparse.py:846: error: Cannot instantiate abstract class "MypyFile" with abstract attributes "_fullname" and "names"  [abstract]                                                                                        
            return MypyFile(body, self.imports, False, self.type_ignores)                                                                                                                                                      
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                                                                                                                                                      
mypy/test/data.py:281: error: Only concrete class can be given where "Type[DataSuiteCollector]" is expected  [type-abstract]                                                                                                   
            parent = self.getparent(DataSuiteCollector)                                                                                                                                                                        
                                    ^~~~~~~~~~~~~~~~~~                                                                                                                                                                         
mypy/checker.py:376: error: Cannot instantiate abstract class "PatternChecker" with abstract attributes "subject" and "subject_type"  [abstract]                                                                              
            self.pattern_checker = PatternChecker(self, self.msg, self.plugin)                                                                                                                                                
                                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                                                                                                                                                 
mypy/build.py:644: error: Cannot instantiate abstract class "SemanticAnalyzer" with abstract attributes "global_decls" and "nonlocal_decls"  [abstract]                                                                        
            self.semantic_analyzer = SemanticAnalyzer(                                                                                                                                                                        
                                     ^                                                                                                                                                                                         
mypy/stubtest.py:1749: error: Cannot instantiate abstract class "_Arguments" with abstract attributes "allowlist", "check_typeshed", ... and "version" (8 methods suppressed)  [abstract]                                      
        return parser.parse_args(args, namespace=_Arguments())                                                                                                                                                                
                                                 ^~~~~~~~~~~~                                                                                                                                                                  
Found 8 errors in 7 files (checked 167 source files)

[tmke8]

I enabled the flag by default in order to look at the mypy_primer output.

The error in https://github.com/mystor/git-revise is from this pattern:

from __future__ import annotations
from typing import Type, cast

class A:
    x: int
    def __new__(cls: Type[A], x: int) -> A:
        self = super().__new__(cls)
        self.x = x
        return cast(A, self)

a = A(3)

I don't think this can be supported...

[tmke8]

https://github.com/encode/starlette has this:

class State:
    _state: typing.Dict[str, typing.Any]

    def __init__(self, state: typing.Optional[typing.Dict[str, typing.Any]] = None):
        if state is None:
            state = {}
        super().__setattr__("_state", state)

Also very difficult to support, I think.

[tmke8]

This pattern in https://github.com/systemd/mkosi

class A:
    CONST: int
    CONST = 4
a = A()

should work though (even though that should be a ClassVar).

I'll fix this.

[sobolevn]

Thanks, this is not a full review: just a bunch of ideas :)

[sobolevn]

We should totally change the error message.
Class A is not abstract by any means.

Maybe we should say: Cannot instantiate aclass "A" with annotated but unset attribute "x"?

[tmke8]

I now went with Class "A" has annotated but unset attributes: "x" because "Cannot instantiate" seemed too strong to me (because the instantiation will work fine at runtime). But I'm not attached to this at all and I'm happy to change it again.

[tmke8]

One question is whether initialization should only be recognized if it happens in the __init__. As the code is right now, any method in a class can first initialize a variable, but maybe that's too loose behavior for people who want to use the new flag.

[tmke8]

I honestly don't understand why I needed to add this check twice, but if I don't, then either the self-check or the tests fails.

[sobolevn]

Maybe because of pass? Isn't it suppose to be continue?

[sobolevn]

Please, resolve merge conflicts

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅