Merge branch 'property-setters'

Author: JukkaL

mypy/checker.py

@@ -416,6 +416,9 @@ def infer_local_variable_type(self, x, y, z):
 
     def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> Type:
         num_abstract = 0
+        if defn.is_property:
+            # HACK: Infer the type of the property.
+            self.visit_decorator(defn.items[0])
         for fdef in defn.items:
             self.check_func_item(fdef.func, name=fdef.func.name())
             if fdef.func.is_abstract:

mypy/checkmember.py

@@ -7,7 +7,7 @@
     Overloaded, TypeVarType, TypeTranslator, UnionType
 )
 from mypy.nodes import TypeInfo, FuncBase, Var, FuncDef, SymbolNode, Context
-from mypy.nodes import ARG_POS, function_type, Decorator
+from mypy.nodes import ARG_POS, function_type, Decorator, OverloadedFuncDef
 from mypy.messages import MessageBuilder
 from mypy.maptype import map_instance_to_supertype
 from mypy.expandtype import expand_type_by_instance
@@ -47,6 +47,10 @@ def analyse_member_access(name: str, typ: Type, node: Context, is_lvalue: bool,
         # Look up the member. First look up the method dictionary.
         method = info.get_method(name)
         if method:
+            if method.is_property:
+                assert isinstance(method, OverloadedFuncDef)
+                method = cast(OverloadedFuncDef, method)
+                return analyze_var(name, method.items[0].var, typ, info, node, is_lvalue, msg)
             if is_lvalue:
                 msg.cant_assign_to_method(node)
             typ = map_instance_to_supertype(typ, method.info)
@@ -114,37 +118,7 @@ def analyse_member_var_access(name: str, itype: Instance, info: TypeInfo,
         v = vv.var
 
     if isinstance(v, Var):
-        # Found a member variable.
-        var = v
-        itype = map_instance_to_supertype(itype, var.info)
-        if var.type:
-            t = expand_type_by_instance(var.type, itype)
-            if var.is_initialized_in_class and isinstance(t, FunctionLike):
-                if is_lvalue:
-                    if var.is_property:
-                        msg.read_only_property(name, info, node)
-                    else:
-                        msg.cant_assign_to_method(node)
-
-                if not var.is_staticmethod:
-                    # Class-level function objects and classmethods become bound
-                    # methods: the former to the instance, the latter to the
-                    # class.
-                    functype = cast(FunctionLike, t)
-                    check_method_type(functype, itype, node, msg)
-                    signature = method_type(functype)
-                    if var.is_property:
-                        # A property cannot have an overloaded type => the cast
-                        # is fine.
-                        return cast(CallableType, signature).ret_type
-                    else:
-                        return signature
-            return t
-        else:
-            if not var.is_ready:
-                msg.cannot_determine_type(var.name(), node)
-            # Implicit 'Any' type.
-            return AnyType()
+        return analyze_var(name, v, itype, info, node, is_lvalue, msg)
     elif isinstance(v, FuncDef):
         assert False, "Did not expect a function"
     elif not v and name not in ['__getattr__', '__setattr__']:
@@ -165,6 +139,45 @@ def analyse_member_var_access(name: str, itype: Instance, info: TypeInfo,
         return msg.has_no_attr(report_type or itype, name, node)
 
 
+def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Context,
+               is_lvalue: bool, msg: MessageBuilder) -> Type:
+    """Analyze access to an attribute via a Var node.
+
+    This is conceptually part of analyse_member_access and the arguments are similar.
+    """
+    # Found a member variable.
+    itype = map_instance_to_supertype(itype, var.info)
+    if var.type:
+        t = expand_type_by_instance(var.type, itype)
+        if var.is_initialized_in_class and isinstance(t, FunctionLike):
+            if is_lvalue:
+                if var.is_property:
+                    if not var.is_settable_property:
+                        msg.read_only_property(name, info, node)
+                else:
+                    msg.cant_assign_to_method(node)
+
+            if not var.is_staticmethod:
+                # Class-level function objects and classmethods become bound
+                # methods: the former to the instance, the latter to the
+                # class.
+                functype = cast(FunctionLike, t)
+                check_method_type(functype, itype, node, msg)
+                signature = method_type(functype)
+                if var.is_property:
+                    # A property cannot have an overloaded type => the cast
+                    # is fine.
+                    return cast(CallableType, signature).ret_type
+                else:
+                    return signature
+        return t
+    else:
+        if not var.is_ready:
+            msg.cannot_determine_type(var.name(), node)
+        # Implicit 'Any' type.
+        return AnyType()
+
+
 def lookup_member_var_or_accessor(info: TypeInfo, name: str,
                                   is_lvalue: bool) -> SymbolNode:
     """Find the attribute/accessor node that refers to a member of a type."""

mypy/nodes.py

@@ -199,6 +199,7 @@ class FuncBase(SymbolNode):
     type = None  # type: mypy.types.Type
     # If method, reference to TypeInfo
     info = None  # type: TypeInfo
+    is_property = False
 
     @abstractmethod
     def name(self) -> str: pass
@@ -380,6 +381,7 @@ class Var(SymbolNode):
     is_staticmethod = False
     is_classmethod = False
     is_property = False
+    is_settable_property = False
 
     def __init__(self, name: str, type: 'mypy.types.Type' = None) -> None:
         self._name = name

mypy/semanal.py

@@ -264,13 +264,17 @@ def is_defined_type_var(self, tvar: str, context: Node) -> bool:
 
     def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         t = []  # type: List[CallableType]
-        for item in defn.items:
+        for i, item in enumerate(defn.items):
             # TODO support decorated overloaded functions properly
             item.is_overload = True
             item.func.is_overload = True
             item.accept(self)
             t.append(cast(CallableType, function_type(item.func,
                                                   self.builtin_type('builtins.function'))))
+            if item.func.is_property and i == 0:
+                # This defines a property, probably with a setter and/or deleter.
+                self.analyse_property_with_multi_part_definition(defn)
+                break
             if not [dec for dec in item.decorators
                     if refers_to_fullname(dec, 'typing.overload')]:
                 self.fail("'overload' decorator expected", item)
@@ -285,6 +289,24 @@ def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         elif self.is_func_scope():
             self.add_local_func(defn, defn)
 
+    def analyse_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -> None:
+        """Analyze a propery defined using multiple methods (e.g., using @x.setter).
+
+        Assume that the first method (@property) has already been analyzed.
+        """
+        defn.is_property = True
+        items = defn.items
+        for item in items[1:]:
+            if len(item.decorators) == 1:
+                node = item.decorators[0]
+                if isinstance(node, MemberExpr):
+                    if node.name == 'setter':
+                        # The first item represents the entire property.
+                        defn.items[0].var.is_settable_property = True
+            else:
+                self.fail("Decorated property not supported", item)
+            item.func.accept(self)
+
     def analyse_function(self, defn: FuncItem) -> None:
         is_method = self.is_class_scope()
         tvarnodes = self.add_func_type_variables_to_symbol_table(defn)
@@ -1198,15 +1220,6 @@ def analyze_types(self, items: List[Node]) -> List[Type]:
         return result
 
     def visit_decorator(self, dec: Decorator) -> None:
-        if not dec.is_overload:
-            if self.is_func_scope():
-                self.add_symbol(dec.var.name(), SymbolTableNode(LDEF, dec),
-                                dec)
-            elif self.type:
-                dec.var.info = self.type
-                dec.var.is_initialized_in_class = True
-                self.add_symbol(dec.var.name(), SymbolTableNode(MDEF, dec),
-                                dec)
         for d in dec.decorators:
             d.accept(self)
         removed = []  # type: List[int]
@@ -1232,13 +1245,22 @@ def visit_decorator(self, dec: Decorator) -> None:
                 removed.append(i)
                 dec.func.is_property = True
                 dec.var.is_property = True
-                if dec.is_overload:
-                    self.fail('A property cannot be overloaded', dec)
                 self.check_decorated_function_is_method('property', dec)
                 if len(dec.func.args) > 1:
                     self.fail('Too many arguments', dec.func)
         for i in reversed(removed):
             del dec.decorators[i]
+        if not dec.is_overload or dec.var.is_property:
+            if self.is_func_scope():
+                self.add_symbol(dec.var.name(), SymbolTableNode(LDEF, dec),
+                                dec)
+            elif self.type:
+                dec.var.info = self.type
+                dec.var.is_initialized_in_class = True
+                self.add_symbol(dec.var.name(), SymbolTableNode(MDEF, dec),
+                                dec)
+        if dec.decorators and dec.var.is_property:
+            self.fail('Decorated property not supported', dec)
         dec.func.accept(self)
         if not dec.decorators and not dec.var.is_property:
             # No non-special decorators left. We can trivially infer the type

mypy/test/data/check-classes.test

@@ -815,6 +815,35 @@ a.f.xx
 a.f = '' # E: Property "f" defined in "A" is read-only
 [builtins fixtures/property.py]
 
+[case testPropertyWithSetter]
+import typing
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: int) -> None:
+        pass
+a = A()
+a.f = a.f
+a.f.x # E: "int" has no attribute "x"
+a.f = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[builtins fixtures/property.py]
+
+[case testPropertyWithDeleterButNoSetter]
+import typing
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.deleter
+    def f(self, x) -> None:
+        pass
+a = A()
+a.f = a.f # E: Property "f" defined in "A" is read-only
+a.f.x # E: "int" has no attribute "x"
+[builtins fixtures/property.py]
+
 
 -- Multiple inheritance, non-object built-in class as base
 -- -------------------------------------------------------

mypy/test/data/semanal-errors.test

@@ -1248,15 +1248,39 @@ class A:
 [case testOverloadedProperty]
 from typing import overload
 class A:
-    @overload  # E: A property cannot be overloaded
+    @overload  # E: Decorated property not supported
     @property
     def f(self) -> int: pass
-    @property  # E: A property cannot be overloaded
+    @property  # E: Decorated property not supported
     @overload
     def f(self) -> int: pass
 [builtins fixtures/property.py]
 [out]
 
+[case testOverloadedProperty2]
+from typing import overload
+class A:
+    @overload
+    def f(self) -> int: pass
+    @property  # E: Decorated property not supported
+    @overload
+    def f(self) -> int: pass
+[builtins fixtures/property.py]
+[out]
+
+[case testDecoratedProperty]
+import typing
+def dec(f): pass
+class A:
+    @dec  # E: Decorated property not supported
+    @property
+    def f(self) -> int: pass
+    @property  # E: Decorated property not supported
+    @dec
+    def g(self) -> int: pass
+[builtins fixtures/property.py]
+[out]
+
 [case testImportTwoModulesWithSameNameInFunction]
 import typing
 def f() -> None: