This is not valid python, hopefully, so it makes things a bit simpler.

class Person:
    _name=None
    @property
    def name(self):
        return self._name
@Person.name.setter
def name(self, value):
    self._name = value

But this is valid python:

class A:
    _data=None
    @property
    def data(self):
        if self._data is None:
            self._data = Data(self)
        return self._data

The thing is the current handling of properties makes us blind to any instance attributes declared in property getters, i.e. we won't not visit the self._data = Data(self) statement. And _data will be wrongly categorized as class variable.

So I think the manner to handle property is to first of all create Function for everything, this will allow us to walk the body of the property getters and have the "correct" representation. Then in a post-processor, we machup property functions into an Attribute.

So turns out proper support for properties is a bit more complex that I would imagine:

• Explicit .getter can be used to override the getter of some inherited property: https://stackoverflow.com/a/66373933

So we can end up with code like:

    class BaseClass(object):
        def __init__(self):
            self._spam = 5
        @property
        def spam(self):
            """BaseClass.getter"""
            return self._spam
        @spam.setter
        def spam(self, value):
            self._spam = value
        @spam.deleter
        def spam(self):
            del self._spam
    class SubClass(BaseClass):
        @BaseClass.spam.getter
        def spam(self): # this overrides the getter only of the property and use the inherited functions for the setter and deleter.
            """SubClass.getter"""
            ...

This brings other considerations for pydoctor, like how to present the fact that some parts of the property methods are inherited and some parts not? And this complexifies the AST building part.

The simplest thing to do would be to always create a property if some parts of a property are defined, show all property methods, but say which are inherited.