Move ClassVar override checks to TypeChecker

Author: miedzinski

mypy/checker.py

@@ -1149,6 +1149,15 @@ def check_compatibility_all_supers(self, lvalue: NameExpr, lvalue_type: Type,
                 lvalue.kind == MDEF and
                 len(lvalue_node.info.bases) > 0):
 
+            for base in lvalue_node.info.mro[1:]:
+                base_node = base.names.get(lvalue_node.name())
+                if base_node is not None:
+                    if not self.check_compatibility_classvar_super(lvalue_node,
+                                                                   base,
+                                                                   base_node.node):
+                        # Show only one error per variable
+                        break
+
             for base in lvalue_node.info.mro[1:]:
                 # Only check __slots__ against the 'object'
                 # If a base class defines a Tuple of 3 elements, a child of
@@ -1257,6 +1266,17 @@ def lvalue_type_from_base(self, expr_node: Var,
 
         return None, None
 
+    def check_compatibility_classvar_super(self, node: Var,
+                                           base: TypeInfo, base_node: Node) -> bool:
+        if (isinstance(base_node, Var) and
+                ((node.is_classvar and not base_node.is_classvar) or
+                 (not node.is_classvar and base_node.is_classvar))):
+            self.fail('Invalid class attribute definition '
+                      '(previously declared on base class "%s")' % base.name(),
+                      node)
+            return False
+        return True
+
     def check_assignment_to_multiple_lvalues(self, lvalues: List[Lvalue], rvalue: Expression,
                                              context: Context,
                                              infer_lvalue_type: bool = True) -> None:

mypy/semanal.py

@@ -2164,10 +2164,7 @@ def check_classvar(self, s: AssignmentStmt) -> None:
         lvalue = s.lvalues[0]
         if len(s.lvalues) != 1 or not isinstance(lvalue, NameExpr):
             return
-        is_classvar = self.check_classvar_definition(lvalue, s.type)
-        if self.is_class_scope() and isinstance(lvalue.node, Var):
-            # Assignments to class variables outside class scope are checked later
-            self.check_classvar_override(lvalue.node, is_classvar)
+        self.check_classvar_definition(lvalue, s.type)
 
     def check_classvar_definition(self, lvalue: NameExpr, typ: Type) -> bool:
         if not isinstance(typ, UnboundType):
@@ -2186,25 +2183,6 @@ def check_classvar_definition(self, lvalue: NameExpr, typ: Type) -> bool:
             self.fail('Invalid ClassVar definition', lvalue)
             return False
 
-    def check_classvar_override(self, node: Var, is_classvar: bool) -> None:
-        name = node.name()
-        for base in self.type.mro[1:]:
-            tnode = base.names.get(name)
-            if tnode is None:
-                continue
-            base_node = tnode.node
-            if isinstance(base_node, Var):
-                v = base_node
-                if (is_classvar and not v.is_classvar) or (not is_classvar and v.is_classvar):
-                    self.fail_classvar_base_incompatibility(node, v)
-                    return
-
-    def fail_classvar_base_incompatibility(self, shadowing: Var, original: Var) -> None:
-        base_name = original.info.name()
-        self.fail('Invalid class attribute definition '
-                  '(previously declared on base class "%s")' % base_name,
-                  shadowing)
-
     def visit_decorator(self, dec: Decorator) -> None:
         for d in dec.decorators:
             d.accept(self)

test-data/unit/check-classvar.test

@@ -220,3 +220,47 @@ class B(A):
     x = None  # type: ClassVar[str]
 [out]
 main:5: error: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
+
+[case testOverrideWithNormalAttribute]
+from typing import ClassVar
+class A:
+    x = 1  # type: ClassVar[int]
+class B(A):
+    x = 2  # type: int
+[out]
+main:5: error: Invalid class attribute definition (previously declared on base class "A")
+
+[case testOverrideWithAttributeWithClassVar]
+from typing import ClassVar
+class A:
+    x = 1  # type: int
+class B(A):
+    x = 2  # type: ClassVar[int]
+[out]
+main:5: error: Invalid class attribute definition (previously declared on base class "A")
+
+[case testOverrideClassVarManyBases]
+from typing import ClassVar
+class A:
+    x = 1  # type: ClassVar[int]
+class B:
+    x = 2  # type: int
+class C(A, B):
+    x = 3  # type: ClassVar[int]
+[out]
+main:7: error: Invalid class attribute definition (previously declared on base class "B")
+
+[case testOverrideClassVarWithClassVar]
+from typing import ClassVar
+class A:
+    x = 1  # type: ClassVar[int]
+class B(A):
+    x = 2  # type: ClassVar[int]
+
+[case testOverrideOnABCSubclass]
+from abc import ABCMeta
+from typing import ClassVar
+class A(metaclass=ABCMeta):
+    x = None  # type: ClassVar[int]
+class B(A):
+    x = 0  # type: ClassVar[int]

test-data/unit/semanal-classvar.test

@@ -54,86 +54,6 @@ MypyFile:1(
       IntExpr(1)
       Any)))
 
-[case testOverrideWithNormalAttribute]
-from typing import ClassVar
-class A:
-    x = 1  # type: ClassVar[int]
-class B(A):
-    x = 2  # type: int
-[out]
-main:5: error: Invalid class attribute definition (previously declared on base class "A")
-
-[case testOverrideWithAttributeWithClassVar]
-from typing import ClassVar
-class A:
-    x = 1  # type: int
-class B(A):
-    x = 2  # type: ClassVar[int]
-[out]
-main:5: error: Invalid class attribute definition (previously declared on base class "A")
-
-[case testOverrideClassVarManyBases]
-from typing import ClassVar
-class A:
-    x = 1  # type: ClassVar[int]
-class B:
-    x = 2  # type: int
-class C(A, B):
-    x = 3  # type: ClassVar[int]
-[out]
-main:7: error: Invalid class attribute definition (previously declared on base class "B")
-
-[case testOverrideClassVarWithClassVar]
-from typing import ClassVar
-class A:
-    x = 1  # type: ClassVar[int]
-class B(A):
-    x = 2  # type: ClassVar[int]
-[out]
-MypyFile:1(
-  ImportFrom:1(typing, [ClassVar])
-  ClassDef:2(
-    A
-    AssignmentStmt:3(
-      NameExpr(x [m])
-      IntExpr(1)
-      builtins.int))
-  ClassDef:4(
-    B
-    BaseType(
-      __main__.A)
-    AssignmentStmt:5(
-      NameExpr(x [m])
-      IntExpr(2)
-      builtins.int)))
-
-[case testOverrideOnABCSubclass]
-from abc import ABCMeta
-from typing import ClassVar
-class A(metaclass=ABCMeta):
-    x = None  # type: ClassVar[int]
-class B(A):
-    x = 0  # type: ClassVar[int]
-[out]
-MypyFile:1(
-  ImportFrom:1(abc, [ABCMeta])
-  ImportFrom:2(typing, [ClassVar])
-  ClassDef:3(
-    A
-    Metaclass(ABCMeta)
-    AssignmentStmt:4(
-      NameExpr(x [m])
-      NameExpr(None [builtins.None])
-      builtins.int))
-  ClassDef:5(
-    B
-    BaseType(
-      __main__.A)
-    AssignmentStmt:6(
-      NameExpr(x [m])
-      IntExpr(0)
-      builtins.int)))
-
 [case testClassVarWithTypeVar]
 from typing import ClassVar, TypeVar
 T = TypeVar('T')