General support for properties

[JukkaL]

Add support for type checking properties.

We should initially support at least the decorator syntax for read-only properties and the assignment syntax for both read-only and read-write properties, as these seem to be the most frequently used variants:

class A:
    @property
    def foo(self) -> int: return 2

    def get_bar(self) -> int: return 3
    def set_bar(self, value: int) -> None: ...
    bar = property(get_bar, set_bar)

Also support defining a deleter and a docstring, at least when using the call syntax.

[JukkaL]

Generic descriptor support would also let us support properties, but the distinction between read-only and settable properties could be lost. A property would have type property[ObjT, ValT], where ObjT is the class that defines the property and ValT is the type of the property value.

In order to properly model settable properties, we should have something like property[ObjT, GetT, SetT], and allow SetT to be undefined. However, there is currently no way of letting the value of a type argument be undefined. We could also generally support default values for type variables, and undefined would a valid default value.

[JukkaL]

Read-only properties using @property work, but not the other forms.

[thomascellerier]

Any progress on this? I am using mypy to check some new production (yes i know :)) python daemon and it worked fine until I started using properties. Do you know of any workaround? Even using the old properties notation i get issues with setters.
A property cannot be overloaded
'overload' decorator expected

Thanks for this great tool.

[gvanrossum]

I'm guessing you're talking about an example like this:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Indeed mypy goes crazy over this:

a.py, line 5: A property cannot be overloaded
a.py, line 5: 'overload' decorator expected
a.py, line 10: Name 'x' is not defined
a.py, line 10: 'overload' decorator expected
a.py, line 14: Name 'x' is not defined
a.py, line 14: 'overload' decorator expected

[JukkaL]

Yeah, this hasn't been implemented yet. It's been on my to-do list for a long time, but since the code I've worked with haven't used setters much I've never gotten around to actually implementing this. The implementation should not be very difficult, though.

I'll try to get this working reasonably soon (though probably only after PyCon, i.e. after April 15th).

[JukkaL]

I just pushed experimental setter support. The following code now works as expected:

class C:
    def __init__(self) -> None:
        self._x = 0

    @property
    def x(self) -> int:
        return self._x

    @x.setter
    def x(self, value: int) -> None:
        self._x = value

    @x.deleter
    def x(self) -> None:
        del self._x

c = C()
c.x = 2 * c.x
c.x = ''   # Error!

The implementation still needs refinement. For example, x = property(...) is not supported.

Let me know if/when you encounter additional issues.

[thomascellerier]

Thanks, the file containing the properties now typechecks.
However I have another file in the same module assigning the property to a variable which fails to typecheck with this error (given a property called x with a getter and setter):
a.py

class C:
    @property
    def x(self) -> Dict[str, Any]:
        return self._x

    @x.setter
    def x(self, value: Dict[str, Any]) -> None:
        self._x = value

b.py

def foo(c: a.C):
    x = c.x

Cannot determine type of 'x'.

[JukkaL]

Do you have cyclic imports? Mypy has trouble with them (#481) in general. However, it should be pretty easy to fix mypy to support your example -- assuming that this actually is due to cyclic imports.