Change the error message

Author: tmke8

mypy/checkexpr.py

@@ -21,7 +21,7 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy.meet import is_overlapping_types, narrow_declared_type
 from mypy.message_registry import ErrorMessage
-from mypy.messages import MessageBuilder
+from mypy.messages import MessageBuilder, format_string_list
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
@@ -1355,24 +1355,21 @@ def check_callable_call(
             # An Enum() call that failed SemanticAnalyzerPass2.check_enum_call().
             return callee.ret_type, callee
 
+        type = callee.type_object() if callee.is_type_obj() else None
         if (
-            callee.is_type_obj()
-            and callee.type_object().is_protocol
+            type is not None
+            and type.is_protocol
             # Exception for Type[...]
             and not callee.from_type_type
         ):
-            self.chk.fail(
-                message_registry.CANNOT_INSTANTIATE_PROTOCOL.format(callee.type_object().name),
-                context,
-            )
+            self.chk.fail(message_registry.CANNOT_INSTANTIATE_PROTOCOL.format(type.name), context)
         elif (
-            callee.is_type_obj()
-            and callee.type_object().is_abstract
+            type is not None
+            and type.is_abstract
             # Exception for Type[...]
             and not callee.from_type_type
             and not callee.type_object().fallback_to_any
         ):
-            type = callee.type_object()
             # Determine whether the implicitly abstract attributes are functions with
             # None-compatible return types.
             abstract_attributes: dict[str, bool] = {}
@@ -1381,8 +1378,19 @@ def check_callable_call(
                     abstract_attributes[attr_name] = self.can_return_none(type, attr_name)
                 else:
                     abstract_attributes[attr_name] = False
-            self.msg.cannot_instantiate_abstract_class(
-                callee.type_object().name, abstract_attributes, context
+            self.msg.cannot_instantiate_abstract_class(type.name, abstract_attributes, context)
+        elif (
+            type is not None
+            and type.uninitialized_vars
+            # Exception for Type[...]
+            and not callee.from_type_type
+            and not callee.type_object().fallback_to_any
+        ):
+            self.chk.fail(
+                message_registry.CLASS_HAS_UNINITIALIZED_VARS.format(
+                    type.name, format_string_list([f'"{v}"' for v in type.uninitialized_vars])
+                ),
+                context,
             )
 
         formal_to_actual = map_actuals_to_formals(

mypy/message_registry.py

@@ -152,6 +152,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 )
 NOT_CALLABLE: Final = "{} not callable"
 TYPE_MUST_BE_USED: Final = "Value of type {} must be used"
+CLASS_HAS_UNINITIALIZED_VARS: Final = 'Class "{}" has annotated but unset attributes: {}'
 
 # Generic
 GENERIC_INSTANCE_VAR_CLASS_ACCESS: Final = (

mypy/nodes.py

@@ -2654,6 +2654,7 @@ class is generic then it will be a type constructor of higher kind.
         "is_protocol",
         "runtime_protocol",
         "abstract_attributes",
+        "uninitialized_vars",
         "deletable_attributes",
         "slots",
         "assuming",
@@ -2703,6 +2704,8 @@ class is generic then it will be a type constructor of higher kind.
     # List of names of abstract attributes together with their abstract status.
     # The abstract status must be one of `NOT_ABSTRACT`, `IS_ABSTRACT`, `IMPLICITLY_ABSTRACT`.
     abstract_attributes: list[tuple[str, int]]
+    # List of names of variables (instance vars and class vars) that are not initialized.
+    uninitialized_vars: list[str]
     deletable_attributes: list[str]  # Used by mypyc only
     # Does this type have concrete `__slots__` defined?
     # If class does not have `__slots__` defined then it is `None`,
@@ -2846,6 +2849,7 @@ def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None
         self.metaclass_type = None
         self.is_abstract = False
         self.abstract_attributes = []
+        self.uninitialized_vars = []
         self.deletable_attributes = []
         self.slots = None
         self.assuming = []
@@ -3066,6 +3070,7 @@ def serialize(self) -> JsonDict:
             "names": self.names.serialize(self.fullname),
             "defn": self.defn.serialize(),
             "abstract_attributes": self.abstract_attributes,
+            "uninitialized_vars": self.uninitialized_vars,
             "type_vars": self.type_vars,
             "has_param_spec_type": self.has_param_spec_type,
             "bases": [b.serialize() for b in self.bases],
@@ -3097,6 +3102,7 @@ def deserialize(cls, data: JsonDict) -> TypeInfo:
         ti._fullname = data["fullname"]
         # TODO: Is there a reason to reconstruct ti.subtypes?
         ti.abstract_attributes = [(attr[0], attr[1]) for attr in data["abstract_attributes"]]
+        ti.uninitialized_vars = data["uninitialized_vars"]
         ti.type_vars = data["type_vars"]
         ti.has_param_spec_type = data["has_param_spec_type"]
         ti.bases = [mypy.types.Instance.deserialize(b) for b in data["bases"]]

mypy/semanal_classprop.py

@@ -39,7 +39,9 @@
 }
 
 
-def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: Errors) -> None:
+def calculate_class_abstract_status(
+    typ: TypeInfo, is_stub_file: bool, errors: Errors, options: Options
+) -> None:
     """Calculate abstract status of a class.
 
     Set is_abstract of the type to True if the type has an unimplemented
@@ -52,6 +54,7 @@ def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: E
     # List of abstract attributes together with their abstract status
     abstract: list[tuple[str, int]] = []
     abstract_in_this_class: list[str] = []
+    uninitialized_vars: set[str] = set()
     if typ.is_newtype:
         # Special case: NewTypes are considered as always non-abstract, so they can be used as:
         #     Config = NewType('Config', Mapping[str, str])
@@ -85,15 +88,29 @@ def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: E
                         abstract_in_this_class.append(name)
             elif isinstance(node, Var):
                 if node.is_abstract_var and name not in concrete:
-                    typ.is_abstract = True
-                    abstract.append((name, IS_ABSTRACT))
-                    if base is typ:
-                        abstract_in_this_class.append(name)
+                    # If this abstract variable comes from a protocol, then `typ`
+                    # is abstract.
+                    if base.is_protocol:
+                        typ.is_abstract = True
+                        abstract.append((name, IS_ABSTRACT))
+                        if base is typ:
+                            abstract_in_this_class.append(name)
+                    elif options.warn_uninitialized_attributes:
+                        uninitialized_vars.add(name)
+                elif (
+                    options.warn_uninitialized_attributes
+                    and not node.is_abstract_var
+                    and name in uninitialized_vars
+                ):
+                    # A variable can also be initialized in a parent class.
+                    uninitialized_vars.remove(name)
             concrete.add(name)
+    typ.abstract_attributes = sorted(abstract)
+    if uninitialized_vars:
+        typ.uninitialized_vars = sorted(list(uninitialized_vars))
     # In stubs, abstract classes need to be explicitly marked because it is too
     # easy to accidentally leave a concrete class abstract by forgetting to
     # implement some methods.
-    typ.abstract_attributes = sorted(abstract)
     if is_stub_file:
         if typ.declared_metaclass and typ.declared_metaclass.type.has_base("abc.ABCMeta"):
             return

mypy/semanal_main.py

@@ -472,7 +472,9 @@ def calculate_class_properties(graph: Graph, scc: list[str], errors: Errors) ->
         for _, node, _ in tree.local_definitions():
             if isinstance(node.node, TypeInfo):
                 with state.manager.semantic_analyzer.file_context(tree, state.options, node.node):
-                    calculate_class_abstract_status(node.node, tree.is_stub, errors)
+                    calculate_class_abstract_status(
+                        node.node, tree.is_stub, errors, graph[module].options
+                    )
                     check_protocol_status(node.node, errors)
                     calculate_class_vars(node.node)
                     add_type_promotion(

test-data/unit/check-protocols.test

@@ -3806,3 +3806,21 @@ a = A()
 reveal_type(a.s)  # N: Revealed type is "builtins.str"
 reveal_type(a.l)  # N: Revealed type is "builtins.list[builtins.str]"
 reveal_type(a.l2)  # N: Revealed type is "builtins.list[builtins.str]"
+
+[case testClassAssignment]
+# flags: --warn-uninitialized-attributes
+from typing import ClassVar, Protocol
+
+class P(Protocol):
+    c: ClassVar[int]
+    c = 2
+class A(P): ...
+A()
+class B: ...
+b: P = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "P")
+class P2(Protocol):
+    c: ClassVar[int] = 2
+class A2(P2): ...
+A2()
+class B2: ...
+b2: P2 = B2()  # E: Incompatible types in assignment (expression has type "B2", variable has type "P2")

test-data/unit/check-warnings.test

@@ -239,13 +239,13 @@ class A:
 # flags: --warn-uninitialized-attributes
 class A:
     x: int
-a = A() # E: Cannot instantiate abstract class "A" with abstract attribute "x"
+a = A() # E: Class "A" has annotated but unset attributes: "x"
 class B(A):
     def __init__(self) -> None:
         self.x = 10
 B()  # OK
 class C(A): ...
-C()  # E: Cannot instantiate abstract class "C" with abstract attribute "x"
+C()  # E: Class "C" has annotated but unset attributes: "x"
 class D(A):
     def f(self) -> None:
         self.x = "foo"  # E: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
@@ -273,9 +273,9 @@ from abc import ABC
 
 class A(ABC):
     x: str
-A()  # E: Cannot instantiate abstract class "A" with abstract attribute "x"
+A()  # E: Class "A" has annotated but unset attributes: "x"
 class B(A): ...
-B()  # E: Cannot instantiate abstract class "B" with abstract attribute "x"
+B()  # E: Class "B" has annotated but unset attributes: "x"
 class C(A):
     def f(self) -> None:
         self.x = "foo"
@@ -287,11 +287,11 @@ class A:
     x: int
     y: str = "foo"
     z: bool
-A()  # E: Cannot instantiate abstract class "A" with abstract attributes "x" and "z"
+A()  # E: Class "A" has annotated but unset attributes: "x" and "z"
 class B(A):
     def __init__(self) -> None:
         self.x = 3
-B()  # E: Cannot instantiate abstract class "B" with abstract attribute "z"
+B()  # E: Class "B" has annotated but unset attributes: "z"
 class C(B):
     def __init__(self) -> None:
         self.z = True
@@ -310,7 +310,7 @@ class A:
     @classmethod
     def f(cls) -> None:
         cls.z = True
-A(3, "foo")  # E: Cannot instantiate abstract class "A" with abstract attribute "z"
+A(3, "foo")  # E: Class "A" has annotated but unset attributes: "z"
 reveal_type(A.z)  # N: Revealed type is "builtins.bool"
 @dataclass
 class A2(A):
@@ -323,7 +323,7 @@ class B:
 
 @dataclass
 class C(B): ...
-C()  # E: Cannot instantiate abstract class "C" with abstract attributes "x" and "y"
+C()  # E: Class "C" has annotated but unset attributes: "x" and "y"
 
 @dataclass
 class D(B):
@@ -341,15 +341,15 @@ from typing import ClassVar
 class A:
     x: int
     z: ClassVar[bool]
-A(3)  # E: Cannot instantiate abstract class "A" with abstract attribute "z"
+A(3)  # E: Class "A" has annotated but unset attributes: "z"
 
 class B:
     x: int
     y: str
 
 @attr.define
 class C(B): ...
-C()  # E: Cannot instantiate abstract class "C" with abstract attributes "x" and "y"
+C()  # E: Class "C" has annotated but unset attributes: "x" and "y"
 
 @attr.define
 class D(B):
@@ -400,14 +400,15 @@ if TYPE_CHECKING:
     class C(B): ...
 else:
     class C: ...
-C()  # E: Cannot instantiate abstract class "C" with abstract attribute "x"
+C()  # E: Class "C" has annotated but unset attributes: "x"
 [file stub.pyi]
 class A:
     x: int
 
 [case testUninitializedAttributeClassVar]
 # flags: --warn-uninitialized-attributes
 from typing import ClassVar
+from typing_extensions import Protocol
 class A:
     CONST: int
     CONST = 4
@@ -417,3 +418,46 @@ class B:
     CONST: ClassVar[int]
     CONST = 4
 B()
+
+class C(Protocol):
+    CONST: ClassVar[int]
+    CONST = 4
+class D(C): ...
+D()
+[builtins fixtures/tuple.pyi]
+
+[case testUninitializedAttributeSuperClass]
+# flags: --warn-uninitialized-attributes
+class A:
+    def __init__(self, x: int):
+        self.x = x
+
+class B(A):
+    x: int
+    def __init__(self, x: int):
+        super().__init__(x)
+
+b = B(0)
+reveal_type(b.x)  # N: Revealed type is "builtins.int"
+
+class C:
+    x: int
+class D(C):
+    x: int
+D()  # E: Class "D" has annotated but unset attributes: "x"
+
+class E:
+    a: int
+    def __init__(self, a: int) -> None:
+         self.a = a
+
+class F(E):
+     a: int
+     b: int
+     def __init__(self, a: int, b: int) -> None:
+          super().__init__(a)
+          # or `self.a = a`
+          self.b = b
+
+E(0)  # ok
+F(1, 1)  # ok