Remove ClassVarType, use Var.is_classvar flag

Author: miedzinski

mypy/checker.py

@@ -25,7 +25,7 @@
 from mypy import nodes
 from mypy.types import (
     Type, AnyType, CallableType, Void, FunctionLike, Overloaded, TupleType, TypedDictType,
-    Instance, NoneTyp, ErrorType, strip_type, TypeType, ClassVarType,
+    Instance, NoneTyp, ErrorType, strip_type, TypeType,
     UnionType, TypeVarId, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarDef,
     true_only, false_only, function_type, is_named_instance
 )
@@ -1575,9 +1575,6 @@ def check_member_assignment(self, instance_type: Type, attribute_type: Type,
 
         Return the inferred rvalue_type and whether to infer anything about the attribute type
         """
-        if isinstance(instance_type, Instance) and isinstance(attribute_type, ClassVarType):
-            self.msg.fail("Illegal assignment to class variable", context)
-
         # Descriptors don't participate in class-attribute access
         if ((isinstance(instance_type, FunctionLike) and instance_type.is_type_obj()) or
                 isinstance(instance_type, TypeType)):

mypy/checkexpr.py

@@ -7,7 +7,7 @@
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, NoneTyp, Void, TypeVarDef,
     TupleType, TypedDictType, Instance, TypeVarType, ErasedType, UnionType,
-    PartialType, DeletedType, UnboundType, UninhabitedType, TypeType, ClassVarType,
+    PartialType, DeletedType, UnboundType, UninhabitedType, TypeType,
     true_only, false_only, is_named_instance, function_type, callable_type, FunctionLike,
     get_typ_args, set_typ_args,
     StarType)
@@ -2218,8 +2218,6 @@ def bool_type(self) -> Instance:
         return self.named_type('builtins.bool')
 
     def narrow_type_from_binder(self, expr: Expression, known_type: Type) -> Type:
-        if isinstance(known_type, ClassVarType):
-            known_type = known_type.item
         if expr.literal >= LITERAL_TYPE:
             restriction = self.chk.binder.get(expr)
             if restriction:

mypy/checkmember.py

@@ -268,6 +268,8 @@ def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Cont
         if is_lvalue and var.is_property and not var.is_settable_property:
             # TODO allow setting attributes in subclass (although it is probably an error)
             msg.read_only_property(name, info, node)
+        if is_lvalue and var.is_classvar:
+            msg.cant_assign_to_classvar(node)
         if var.is_initialized_in_class and isinstance(t, FunctionLike) and not t.is_type_obj():
             if is_lvalue:
                 if var.is_property:

mypy/messages.py

@@ -61,6 +61,7 @@
 CANNOT_ACCESS_INIT = 'Cannot access "__init__" directly'
 CANNOT_ASSIGN_TO_METHOD = 'Cannot assign to a method'
 CANNOT_ASSIGN_TO_TYPE = 'Cannot assign to a type'
+CANNOT_ASSIGN_TO_CLASSVAR = 'Illegal assignment to class variable'
 INCONSISTENT_ABSTRACT_OVERLOAD = \
     'Overloaded method has both abstract and non-abstract variants'
 READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE = \
@@ -814,6 +815,9 @@ def base_class_definitions_incompatible(self, name: str, base1: TypeInfo,
     def cant_assign_to_method(self, context: Context) -> None:
         self.fail(CANNOT_ASSIGN_TO_METHOD, context)
 
+    def cant_assign_to_classvar(self, context: Context) -> None:
+        self.fail(CANNOT_ASSIGN_TO_CLASSVAR, context)
+
     def read_only_property(self, name: str, type: TypeInfo,
                            context: Context) -> None:
         self.fail('Property "{}" defined in "{}" is read-only'.format(

mypy/nodes.py

@@ -637,13 +637,15 @@ class Var(SymbolNode):
     is_classmethod = False
     is_property = False
     is_settable_property = False
+    is_classvar = False
     # Set to true when this variable refers to a module we were unable to
     # parse for some reason (eg a silenced module)
     is_suppressed_import = False
 
     FLAGS = [
         'is_self', 'is_ready', 'is_initialized_in_class', 'is_staticmethod',
-        'is_classmethod', 'is_property', 'is_settable_property', 'is_suppressed_import'
+        'is_classmethod', 'is_property', 'is_settable_property', 'is_suppressed_import',
+        'is_classvar'
     ]
 
     def __init__(self, name: str, type: 'mypy.types.Type' = None) -> None:

mypy/semanal.py

@@ -73,7 +73,7 @@
 from mypy.errors import Errors, report_internal_error
 from mypy.types import (
     NoneTyp, CallableType, Overloaded, Instance, Type, TypeVarType, AnyType,
-    FunctionLike, UnboundType, TypeList, TypeVarDef, TypeType, ClassVarType,
+    FunctionLike, UnboundType, TypeList, TypeVarDef, TypeType,
     TupleType, UnionType, StarType, EllipsisType, function_type, TypedDictType,
 )
 from mypy.nodes import implicit_module_attrs
@@ -1330,6 +1330,7 @@ def anal_type(self, t: Type, allow_tuple_literal: bool = False,
     def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         for lval in s.lvalues:
             self.analyze_lvalue(lval, explicit_type=s.type is not None)
+        self.check_classvar(s)
         s.rvalue.accept(self)
         if s.type:
             allow_tuple_literal = isinstance(s.lvalues[-1], (TupleExpr, ListExpr))
@@ -1363,7 +1364,6 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         self.process_typevar_declaration(s)
         self.process_namedtuple_definition(s)
         self.process_typeddict_definition(s)
-        self.check_classvar_definition(s)
 
         if (len(s.lvalues) == 1 and isinstance(s.lvalues[0], NameExpr) and
                 s.lvalues[0].name == '__all__' and s.lvalues[0].kind == GDEF and
@@ -2160,9 +2160,51 @@ def build_typeddict_typeinfo(self, name: str, items: List[str],
 
         return info
 
-    def check_classvar_definition(self, s: AssignmentStmt) -> None:
-        if isinstance(s.type, ClassVarType) and not self.is_class_scope():
-            self.fail("Invalid ClassVar definition", s)
+    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)
+
+    def check_classvar_definition(self, lvalue: NameExpr, typ: Type) -> bool:
+        if not isinstance(typ, UnboundType):
+            return False
+        sym = self.lookup_qualified(typ.name, typ)
+        if not sym or not sym.node:
+            return False
+        fullname = sym.node.fullname()
+        if fullname != 'typing.ClassVar':
+            return False
+        if self.is_class_scope() or not isinstance(lvalue.node, Var):
+            node = cast(Var, lvalue.node)
+            node.is_classvar = True
+            return True
+        else:
+            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
+            print(base_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:

mypy/subtypes.py

@@ -3,8 +3,7 @@
 from mypy.types import (
     Type, AnyType, UnboundType, TypeVisitor, ErrorType, FormalArgument, Void, NoneTyp,
     Instance, TypeVarType, CallableType, TupleType, TypedDictType, UnionType, Overloaded,
-    ErasedType, TypeList, PartialType, DeletedType, UninhabitedType, TypeType, is_named_instance,
-    ClassVarType,
+    ErasedType, TypeList, PartialType, DeletedType, UninhabitedType, TypeType, is_named_instance
 )
 import mypy.applytype
 import mypy.constraints
@@ -53,9 +52,6 @@ def is_subtype(left: Type, right: Type,
         return any(is_subtype(left, item, type_parameter_checker,
                               ignore_pos_arg_names=ignore_pos_arg_names)
                    for item in right.items)
-    elif isinstance(right, ClassVarType):
-        return is_subtype(left, right.item, type_parameter_checker,
-                          ignore_pos_arg_names=ignore_pos_arg_names)
     else:
         return left.accept(SubtypeVisitor(right, type_parameter_checker,
                                           ignore_pos_arg_names=ignore_pos_arg_names))

mypy/typeanal.py

@@ -4,7 +4,7 @@
 from typing import Callable, cast, List, Optional
 
 from mypy.types import (
-    Type, UnboundType, TypeVarType, TupleType, TypedDictType, UnionType, Instance, ClassVarType,
+    Type, UnboundType, TypeVarType, TupleType, TypedDictType, UnionType, Instance,
     AnyType, CallableType, Void, NoneTyp, DeletedType, TypeList, TypeVarDef, TypeVisitor,
     StarType, PartialType, EllipsisType, UninhabitedType, TypeType, get_typ_args, set_typ_args,
 )
@@ -149,11 +149,13 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                 item = items[0]
                 return TypeType(item, line=t.line)
             elif fullname == 'typing.ClassVar':
+                if len(t.args) == 0:
+                    return AnyType(line=t.line)
                 if len(t.args) != 1:
                     self.fail('ClassVar[...] must have exactly one type argument', t)
                     return AnyType()
                 items = self.anal_array(t.args)
-                return ClassVarType(items[0])
+                return items[0]
             elif fullname == 'mypy_extensions.NoReturn':
                 return UninhabitedType(is_noreturn=True)
             elif sym.kind == TYPE_ALIAS:

mypy/types.py

@@ -1189,29 +1189,6 @@ def deserialize(cls, data: JsonDict) -> 'TypeType':
         return TypeType(Type.deserialize(data['item']))
 
 
-class ClassVarType(Type):
-    """The ClassVar[T] type.
-
-    In all typechecking scenarios, behaves like T.
-    """
-    item = None  # type: Type
-
-    def __init__(self, item: Type, *, line: int = -1, column: int = -1) -> None:
-        super().__init__(line, column)
-        self.item = item
-
-    def accept(self, visitor: 'TypeVisitor[T]') -> T:
-        return visitor.visit_classvar_type(self)
-
-    def serialize(self) -> JsonDict:
-        return {'.class': 'ClassVarType', 'item': self.item.serialize()}
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> 'ClassVarType':
-        assert data['.class'] == 'ClassVarType'
-        return ClassVarType(Type.deserialize(data['item']))
-
-
 #
 # Visitor-related classes
 #
@@ -1303,9 +1280,6 @@ def visit_ellipsis_type(self, t: EllipsisType) -> T:
     def visit_type_type(self, t: TypeType) -> T:
         pass
 
-    def visit_classvar_type(self, t: ClassVarType) -> T:
-        pass
-
 
 class TypeTranslator(TypeVisitor[Type]):
     """Identity type transformation.
@@ -1539,9 +1513,6 @@ def visit_ellipsis_type(self, t: EllipsisType) -> str:
     def visit_type_type(self, t: TypeType) -> str:
         return 'Type[{}]'.format(t.item.accept(self))
 
-    def visit_classvar_type(self, t: ClassVarType) -> str:
-        return 'ClassVar[{}]'.format(t.item.accept(self))
-
     def list_str(self, a: List[Type]) -> str:
         """Convert items of an array to strings (pretty-print types)
         and join the results with commas.

test-data/unit/check-classvar.test

@@ -12,7 +12,7 @@ A().x = 2
 [out]
 main:4: error: Illegal assignment to class variable
 
-[case testAssignmentOnSubclass]
+[case testAssignmentOnSubclassInstance]
 from typing import ClassVar
 class A:
     x = 1  # type: ClassVar[int]
@@ -22,18 +22,64 @@ B().x = 2
 [out]
 main:6: error: Illegal assignment to class variable
 
+[case testOverrideOnSelf]
+from typing import ClassVar
+class A:
+    x = None  # type: ClassVar[int]
+    def __init__(self) -> None:
+        self.x = 0
+[out]
+main:5: error: Illegal assignment to class variable
+
+[case testOverrideOnSelfInSubclass]
+from typing import ClassVar
+class A:
+    x = None  # type: ClassVar[int]
+class B(A):
+    def __init__(self) -> None:
+        self.x = 0
+[out]
+main:6: error: Illegal assignment to class variable
+
 [case testReadingFromInstance]
 from typing import ClassVar
 class A:
     x = 1  # type: ClassVar[int]
 A().x
 
-[case testTypecheck]
+[case testTypecheckSimple]
 from typing import ClassVar
 class A:
     x = 1  # type: ClassVar[int]
 y = A.x  # type: int
 
+[case testTypecheckWithUserType]
+from typing import ClassVar
+class A:
+    pass
+class B:
+    x = A()  # type: ClassVar[A]
+
+[case testTypeCheckOnAssignment]
+from typing import ClassVar
+class A:
+    pass
+class B:
+    pass
+class C:
+    x = None  # type: ClassVar[A]
+C.x = B()
+[out]
+main:8: error: Incompatible types in assignment (expression has type "B", variable has type "A")
+
+[case testRevealType]
+from typing import ClassVar
+class A:
+    x = None  # type: ClassVar[int]
+reveal_type(A.x)
+[out]
+main:4: error: Revealed type is 'builtins.int'
+
 [case testInfer]
 from typing import ClassVar
 class A:
@@ -42,3 +88,53 @@ y = A.x
 reveal_type(y)
 [out]
 main:5: error: Revealed type is 'builtins.int'
+
+[case testAssignmentOnUnion]
+from typing import ClassVar, Union
+class A:
+    x = None  # type: int
+class B:
+    x = None  # type: ClassVar[int]
+c = A()  # type: Union[A, B]
+c.x = 1
+[out]
+main:7: error: Illegal assignment to class variable
+
+[case testAssignmentOnInstanceFromType]
+from typing import ClassVar, Type
+class A:
+    x = None  # type: ClassVar[int]
+def f(a: Type[A]) -> None:
+    a().x = 0
+[out]
+main:5: error: Illegal assignment to class variable
+
+[case testAssignmentOnInstanceFromSubclassType]
+from typing import ClassVar, Type
+class A:
+    x = None  # type: ClassVar[int]
+class B(A):
+    pass
+def f(b: Type[B]) -> None:
+    b().x = 0
+[out]
+main:7: error: Illegal assignment to class variable
+
+[case testAssignmentWithGeneric]
+from typing import ClassVar, List
+class A:
+    x = None  # type: ClassVar[List[int]]
+A.x = ['a']
+[builtins fixtures/list.pyi]
+[out]
+main:4: error: List item 0 has incompatible type "str"
+
+[case testAssignmentToCallableRet]
+from typing import ClassVar, Type
+class A:
+    x = None  # type: ClassVar[int]
+def f() -> A:
+    return A()
+f().x = 0
+[out]
+main:6: error: Illegal assignment to class variable