@property now returns Name.type == 'property', fixes muffinmad/anakin-language-server#15

CHANGELOG.rst

@@ -13,8 +13,12 @@ Unreleased
   - ``Definition.module_path``
   - ``Refactoring.get_renames``
   - ``Refactoring.get_changed_files``
+- Functions with ``@property`` now return ``property`` instead of ``function``
+  in ``Name().type``
 - Started using annotations
 
+This is likely going to be the last minor release before 1.0.
+
 0.17.2 (2020-07-17)
 +++++++++++++++++++
 

conftest.py

@@ -130,7 +130,11 @@ def goto_or_help(request, Script):
 
 @pytest.fixture(scope='session', params=['goto', 'help', 'infer'])
 def goto_or_help_or_infer(request, Script):
-    return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs)
+    def do(code, *args, **kwargs):
+        return getattr(Script(code), request.param)(*args, **kwargs)
+
+    do.type = request.param
+    return do
 
 
 @pytest.fixture(scope='session')

jedi/api/classes.py

@@ -174,7 +174,7 @@ class BaseName(object):
         'function'
 
         Valid values for type are ``module``, ``class``, ``instance``, ``function``,
-        ``param``, ``path``, ``keyword`` and ``statement``.
+        ``param``, ``path``, ``keyword``, ``property`` and ``statement``.
 
         """
         tree_name = self._name.tree_name

jedi/inference/value/klass.py

@@ -37,7 +37,8 @@ py__doc__()                            Returns the docstring for a value.
 
 """
 from jedi import debug
-from jedi.parser_utils import get_cached_parent_scope, expr_is_dotted
+from jedi.parser_utils import get_cached_parent_scope, expr_is_dotted, \
+    function_is_property
 from jedi.inference.cache import inference_state_method_cache, CachedMetaClass, \
     inference_state_method_generator_cache
 from jedi.inference import compiled
@@ -72,6 +73,20 @@ class ClassName(TreeNameDefinition):
             else:
                 yield result_value
 
+    @property
+    def api_type(self):
+        if self.tree_name is not None:
+            definition = self.tree_name.get_definition()
+            if definition.type == 'funcdef':
+                if function_is_property(definition):
+                    # This essentially checks if there is an @property before
+                    # the function. @property could be something different, but
+                    # any programmer that redefines property as something that
+                    # is not really a property anymore, should be shot. (i.e.
+                    # this is a heuristic).
+                    return 'property'
+        return super().api_type
+
 
 class ClassFilter(ParserTreeFilter):
     def __init__(self, class_value, node_context=None, until_position=None,

jedi/parser_utils.py

@@ -316,3 +316,4 @@ def _function_is_x_method(method_name):
 
 function_is_staticmethod = _function_is_x_method('staticmethod')
 function_is_classmethod = _function_is_x_method('classmethod')
+function_is_property = _function_is_x_method('property')

jedi/plugins/stdlib.py

@@ -384,6 +384,8 @@ def builtins_classmethod(functions, value, arguments):
 
 
 class PropertyObject(AttributeOverwrite, ValueWrapper):
+    api_type = 'property'
+
     def __init__(self, property_obj, function):
         super().__init__(property_obj)
         self._function = function

test/test_api/test_classes.py

@@ -373,6 +373,34 @@ def test_type_II(Script):
             assert c.type == 'keyword'
 
 
+@pytest.mark.parametrize(
+    'added_code, expected_type, expected_infer_type', [
+        ('Foo().x', 'property', 'instance'),
+        ('Foo.x', 'property', 'property'),
+        ('Foo().y', 'function', 'function'),
+        ('Foo.y', 'function', 'function'),
+        ('Foo().z', 'function', 'function'),
+        ('Foo.z', 'function', 'function'),
+    ]
+)
+def test_class_types(goto_or_help_or_infer, added_code, expected_type,
+                     expected_infer_type):
+    code = dedent('''\
+        class Foo:
+            @property
+            def x(self): return 1
+            @staticmethod
+            def y(self): ...
+            @classmethod
+            def z(self): ...
+        ''')
+    d, = goto_or_help_or_infer(code + added_code)
+    if goto_or_help_or_infer.type == 'infer':
+        assert d.type == expected_infer_type
+    else:
+        assert d.type == expected_type
+
+
 """
 This tests the BaseName.goto function, not the jedi
 function. They are not really different in functionality, but really