New approach

Author: sobolevn

mypy/checker.py

@@ -2091,6 +2091,7 @@ def check_assignment(self, lvalue: Lvalue, rvalue: Expression, infer_lvalue_type
                                                       infer_lvalue_type)
         else:
             self.try_infer_partial_generic_type_from_assignment(lvalue, rvalue, '=')
+            self.try_infer_partial_generic_type_from_super(lvalue, rvalue)
             lvalue_type, index_lvalue, inferred = self.check_lvalue(lvalue)
             # If we're assigning to __getattr__ or similar methods, check that the signature is
             # valid.
@@ -2241,6 +2242,40 @@ def try_infer_partial_generic_type_from_assignment(self,
                 var.type = fill_typevars_with_any(typ.type)
                 del partial_types[var]
 
+    def try_infer_partial_generic_type_from_super(self, lvalue: Lvalue,
+                                                  rvalue: Expression) -> None:
+        """Try to infer a precise type for partial generic type from super types.
+
+        Example where this happens:
+
+            class P:
+                x: List[int]
+
+            class C(P):
+                x = []  # Infer List[int] as type of 'x'
+
+        """
+        var = None
+        if (isinstance(lvalue, NameExpr)
+                and isinstance(lvalue.node, Var)
+                and lvalue.node.type is None):
+            var = lvalue.node
+            self.infer_partial_type(var, lvalue,
+                                    self.expr_checker.accept(rvalue))
+
+        if var is not None:
+            partial_types = self.find_partial_types(var)
+            if partial_types is None:
+                return
+
+            parent_type = self.get_defined_in_base_class(var)
+            if parent_type is not None and is_valid_inferred_type(parent_type):
+                self.set_inferred_type(var, lvalue, parent_type)
+                if isinstance(lvalue, RefExpr):
+                    # We need this to escape another round of inference:
+                    lvalue.is_inferred_def = False
+                del partial_types[var]
+
     def check_compatibility_all_supers(self, lvalue: RefExpr, lvalue_type: Optional[Type],
                                        rvalue: Expression) -> bool:
         lvalue_node = lvalue.node
@@ -4870,12 +4905,6 @@ def enter_partial_types(self, *, is_function: bool = False,
                         and not permissive):
                     var.type = NoneType()
                 else:
-                    if is_class:
-                        # Special case: possibly super-type defines the type for us?
-                        parent_type = self.get_defined_in_base_class(var)
-                        if parent_type is not None:
-                            var.type = parent_type
-                            self.partial_reported.add(var)
                     if var not in self.partial_reported and not permissive:
                         self.msg.need_annotation_for_var(var, context, self.options.python_version)
                         self.partial_reported.add(var)

test-data/unit/check-classes.test

@@ -992,6 +992,24 @@ class C(P, M):
 reveal_type(C.x)  # N: Revealed type is "builtins.list[builtins.int]"
 [builtins fixtures/list.pyi]
 
+[case testAccessingClassAttributeWithTypeInferenceWithMixinTypeConflict]
+from typing import List
+class P:
+    x: List[int]
+class M:
+    x: List[str]
+class C(P, M):
+    x = []  # E: Incompatible types in assignment (expression has type "List[int]", base class "M" defined the type as "List[str]")
+reveal_type(C.x)  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testClassAttributeWithTypeInferenceNoParentType]
+class P:
+    ...
+class C(P):
+    x = []  # E: Need type annotation for "x" (hint: "x: List[<type>] = ...")
+[builtins fixtures/list.pyi]
+
 [case testClassAttributeWithTypeInferenceInvalidType]
 from typing import List
 class P: