Fix calling class methods from constructors (pyccel#2087)

Visit class methods in the order that they are called. Fixes pyccel#2085

Author: EmilyBourne

CHANGELOG.md

@@ -90,6 +90,7 @@ All notable changes to this project will be documented in this file.
 -   #2041 : Include all type extension methods by default.
 -   #2082 : Allow the use of a list comprehension to initialise an array.
 -   #2094 : Fix slicing of array allocated in an if block.
+-   #2085 : Fix calling class methods before they are defined.
 
 ### Changed
 

pyccel/ast/core.py

@@ -3449,6 +3449,47 @@ def add_new_interface(self, interface):
         interface.set_current_user_node(self)
         self._interfaces += (interface,)
 
+    def update_method(self, syntactic_method, semantic_method):
+        """
+        Replace a syntactic_method with its semantic equivalent.
+
+        Replace a syntactic_method with its semantic equivalent.
+
+        Parameters
+        ----------
+        syntactic_method : FunctionDef
+            The method that has already been added to the class.
+        semantic_method : FunctionDef
+            The method that will replace the syntactic_method.
+        """
+        assert isinstance(semantic_method, FunctionDef)
+        assert syntactic_method in self._methods
+        assert semantic_method.is_semantic
+        syntactic_method.remove_user_node(self)
+        semantic_method.set_current_user_node(self)
+        self._methods = tuple(m for m in self._methods if m is not syntactic_method) + (semantic_method,)
+
+    def update_interface(self, syntactic_interface, semantic_interface):
+        """
+        Replace a syntactic_interface with its semantic equivalent.
+
+        Replace a syntactic_interface with its semantic equivalent.
+
+        Parameters
+        ----------
+        syntactic_interface : FunctionDef
+            The interface that has already been added to the class.
+        semantic_interface : FunctionDef
+            The interface that will replace the syntactic_interface.
+        """
+        assert isinstance(semantic_interface, Interface)
+        assert syntactic_interface in self._methods
+        assert semantic_interface.is_semantic
+        syntactic_interface.remove_user_node(self)
+        semantic_interface.set_current_user_node(self)
+        self._methods = tuple(m for m in self._methods if m is not syntactic_interface)
+        self._interfaces = tuple(m for m in self._interfaces if m is not syntactic_interface) + (semantic_interface,)
+
     def get_method(self, name, raise_error = True):
         """
         Get the method `name` of the current class.
@@ -3478,6 +3519,11 @@ def get_method(self, name, raise_error = True):
         ValueError
             Raised if the method cannot be found.
         """
+        method = next((i for i in chain(self.methods, self.interfaces) \
+                if i.name == name and i.pyccel_staging == 'syntactic'), None)
+        if method:
+            return method
+
         if self.scope is not None:
             # Collect translated name from scope
             try:

pyccel/codegen/printing/ccode.py

@@ -21,7 +21,7 @@
 
 from pyccel.ast.builtin_methods.dict_methods  import DictItems
 
-from pyccel.ast.core      import Declare, For, CodeBlock
+from pyccel.ast.core      import Declare, For, CodeBlock, ClassDef
 from pyccel.ast.core      import FuncAddressDeclare, FunctionCall, FunctionCallArgument
 from pyccel.ast.core      import Allocate, Deallocate
 from pyccel.ast.core      import FunctionAddress
@@ -636,7 +636,8 @@ def _handle_inline_func_call(self, expr):
         if parent_assign:
             body.substitute(new_res_vars, orig_res_vars)
 
-        if func.global_vars or func.global_funcs:
+        if func.global_vars or func.global_funcs and \
+                not func.get_direct_user_nodes(lambda u: isinstance(u, ClassDef)):
             mod = func.get_direct_user_nodes(lambda x: isinstance(x, Module))[0]
             self.add_import(Import(mod.name, [AsName(v, v.name) \
                 for v in (*func.global_vars, *func.global_funcs)]))

pyccel/codegen/printing/fcode.py

@@ -30,7 +30,7 @@
 
 from pyccel.ast.core import FunctionDef, FunctionDefArgument, FunctionDefResult
 from pyccel.ast.core import SeparatorComment, Comment
-from pyccel.ast.core import ConstructorCall
+from pyccel.ast.core import ConstructorCall, ClassDef
 from pyccel.ast.core import FunctionCallArgument
 from pyccel.ast.core import FunctionAddress
 from pyccel.ast.core import Return, Module, For
@@ -464,7 +464,9 @@ def _handle_inline_func_call(self, expr, assign_lhs = None):
 
         for i in func.imports:
             self.add_import(i)
-        if func.global_vars or func.global_funcs:
+
+        if (func.global_vars or func.global_funcs) and \
+                not func.get_direct_user_nodes(lambda u: isinstance(u, ClassDef)):
             mod = func.get_direct_user_nodes(lambda x: isinstance(x, Module))[0]
             current_mod = expr.get_user_nodes(Module, excluded_nodes=(FunctionCall,))[0]
             if current_mod is not mod:
@@ -2495,7 +2497,8 @@ def _print_ClassDef(self, expr):
 
         aliases = []
         names   = []
-        methods = ''.join(f'procedure :: {method.name} => {method.cls_name}\n' for method in expr.methods)
+        methods = ''.join(f'procedure :: {method.name} => {method.cls_name}\n' for method in expr.methods \
+                if not method.is_inline)
         for i in expr.interfaces:
             names = ','.join(f.cls_name for f in i.functions if not f.is_inline)
             if names:

pyccel/codegen/printing/pycode.py

@@ -542,6 +542,8 @@ def _print_FunctionCall(self, expr):
         args = expr.args
         if func.arguments and func.arguments[0].bound_argument:
             func_name = f'{self._print(args[0])}.{func_name}'
+            if 'property' in func.decorators:
+                return func_name
             args = args[1:]
         args_str = ', '.join(self._print(i) for i in args)
         code = f'{func_name}({args_str})'

pyccel/parser/semantic.py

@@ -2966,7 +2966,6 @@ def _visit_DottedName(self, expr):
 
         # look for a class method
         if isinstance(rhs, FunctionCall):
-            method = cls_base.get_method(rhs_name)
             macro = self.scope.find(rhs_name, 'macros')
             if macro is not None:
                 master = macro.master
@@ -2976,7 +2975,15 @@ def _visit_DottedName(self, expr):
                 args = macro.apply(args)
                 return FunctionCall(master, args, self._current_function)
 
+            method = cls_base.get_method(rhs_name)
+
             args = [FunctionCallArgument(visited_lhs), *self._handle_function_args(rhs.args)]
+            if not method.is_semantic:
+                if not method.is_inline:
+                    method = self._annotate_the_called_function_def(method)
+                else:
+                    method = self._annotate_the_called_function_def(method, function_call_args=args)
+
             if cls_base.name == 'numpy.ndarray':
                 numpy_class = method.cls_name
                 self.insert_import('numpy', AsName(numpy_class, numpy_class.name))
@@ -2992,6 +2999,12 @@ def _visit_DottedName(self, expr):
             # class property?
             else:
                 method = cls_base.get_method(rhs_name)
+                if not method.is_semantic:
+                    if not method.is_inline:
+                        method = self._annotate_the_called_function_def(method)
+                    else:
+                        method = self._annotate_the_called_function_def(method,
+                                    function_call_args=(FunctionCallArgument(visited_lhs),))
                 assert 'property' in method.decorators
                 if cls_base.name == 'numpy.ndarray':
                     numpy_class = method.cls_name
@@ -4348,7 +4361,7 @@ def unpack(ann):
             if cls_name:
                 # update the class methods
                 if not is_interface:
-                    bound_class.add_new_method(func)
+                    bound_class.update_method(expr, func)
 
             new_semantic_funcs += [func]
             if expr.python_ast:
@@ -4374,7 +4387,7 @@ def unpack(ann):
             if expr.python_ast:
                 new_semantic_funcs.set_current_ast(expr.python_ast)
             if cls_name:
-                bound_class.add_new_interface(new_semantic_funcs)
+                bound_class.update_interface(expr, new_semantic_funcs)
             self.insert_function(new_semantic_funcs)
 
         return EmptyNode()
@@ -4455,78 +4468,71 @@ def _visit_ClassDef(self, expr):
                 docstring = docstring, class_type = dtype)
         self.scope.parent_scope.insert_class(cls)
 
-        methods = list(expr.methods)
-        init_func = None
+        methods = expr.methods
+        for method in methods:
+            cls.add_new_method(method)
 
-        if not any(method.name == '__init__' for method in methods):
+        syntactic_init_func = next((method for method in methods if method.name == '__init__'), None)
+        if syntactic_init_func is None:
             argument = FunctionDefArgument(Variable(dtype, 'self', cls_base = cls), bound_argument = True)
             self.scope.insert_symbol('__init__')
             scope = self.create_new_function_scope('__init__')
             init_func = FunctionDef('__init__', [argument], (), [], cls_name=cls.name, scope=scope)
             self.exit_function_scope()
             self.insert_function(init_func)
             cls.add_new_method(init_func)
-            methods.append(init_func)
-
-        for (i, method) in enumerate(methods):
-            m_name = method.name
-            if m_name == '__init__':
-                if init_func is None:
-                    self._visit(method)
-                    init_func = self.scope.functions.pop(m_name)
-
-                if isinstance(init_func, Interface):
-                    errors.report("Pyccel does not support interface constructor", symbol=method,
-                        severity='fatal')
-                methods.pop(i)
-
-                # create a new attribute to check allocation
-                deallocater_lhs = Variable(dtype, 'self', cls_base = cls, is_argument=True)
-                deallocater = DottedVariable(lhs = deallocater_lhs, name = self.scope.get_new_name('is_freed'),
-                                             class_type = PythonNativeBool(), is_private=True)
-                cls.add_new_attribute(deallocater)
-                deallocater_assign = Assign(deallocater, LiteralFalse())
-                init_func.body.insert2body(deallocater_assign, back=False)
-                break
-
-        if not init_func:
-            errors.report(UNDEFINED_INIT_METHOD, symbol=name,
-                   bounding_box=(self.current_ast_node.lineno, self.current_ast_node.col_offset),
-                   severity='error')
+        else:
+            self._visit(syntactic_init_func)
+            init_func = self.scope.functions.pop('__init__')
 
-        for i in methods:
-            self._visit(i)
+        if isinstance(init_func, Interface):
+            errors.report("Pyccel does not support interface constructor", symbol=init_func,
+                severity='fatal')
 
-        if not any(method.name == '__del__' for method in methods):
+        # create a new attribute to check allocation
+        deallocater_lhs = Variable(dtype, 'self', cls_base = cls, is_argument=True)
+        deallocater = DottedVariable(lhs = deallocater_lhs, name = self.scope.get_new_name('is_freed'),
+                                     class_type = PythonNativeBool(), is_private=True)
+        cls.add_new_attribute(deallocater)
+        deallocater_assign = Assign(deallocater, LiteralFalse())
+        init_func.body.insert2body(deallocater_assign, back=False)
+
+        syntactic_method = next((m for m in cls.methods if not m.is_semantic), None)
+        while syntactic_method:
+            self._visit(syntactic_method)
+            syntactic_method = next((m for m in cls.methods if not m.is_semantic), None)
+
+        syntactic_del_func = next((method for method in methods if method.name == '__del__'), None)
+        if syntactic_del_func is None:
             argument = FunctionDefArgument(Variable(dtype, 'self', cls_base = cls), bound_argument = True)
             self.scope.insert_symbol('__del__')
             scope = self.create_new_function_scope('__del__')
             del_method = FunctionDef('__del__', [argument], (), [Pass()], scope=scope)
             self.exit_function_scope()
             self.insert_function(del_method)
             cls.add_new_method(del_method)
-
-        for method in cls.methods:
-            if method.name == '__del__':
-                self._current_function = method.name
-                attribute = []
-                for attr in cls.attributes:
-                    if not attr.on_stack:
-                        attribute.append(attr)
-                    elif isinstance(attr.class_type, CustomDataType) and not attr.is_alias:
-                        attribute.append(attr)
-                if attribute:
-                    # Create a new list that store local attributes
-                    self._allocs.append(set())
-                    self._pointer_targets.append({})
-                    self._allocs[-1].update(attribute)
-                    method.body.insert2body(*self._garbage_collector(method.body))
-                    self._pointer_targets.pop()
-                condition = If(IfSection(PyccelNot(deallocater),
-                                [method.body]+[Assign(deallocater, LiteralTrue())]))
-                method.body = [condition]
-                self._current_function = None
-                break
+        else:
+            del_method = cls.get_method('__del__')
+
+        # Add destructors to __del__ method
+        self._current_function = del_method.name
+        attribute = []
+        for attr in cls.attributes:
+            if not attr.on_stack:
+                attribute.append(attr)
+            elif isinstance(attr.class_type, CustomDataType) and not attr.is_alias:
+                attribute.append(attr)
+        if attribute:
+            # Create a new list that store local attributes
+            self._allocs.append(set())
+            self._pointer_targets.append({})
+            self._allocs[-1].update(attribute)
+            del_method.body.insert2body(*self._garbage_collector(del_method.body))
+            self._pointer_targets.pop()
+        condition = If(IfSection(PyccelNot(deallocater),
+                        [del_method.body]+[Assign(deallocater, LiteralTrue())]))
+        del_method.body = [condition]
+        self._current_function = None
 
         self.exit_class_scope()
 

tests/epyccel/classes/classes_8.py

@@ -0,0 +1,23 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, missing-class-docstring
+
+class A:
+    def __init__(self, x : float):
+        self._x = x
+        self._y : float
+        self._construct_y()
+        self._construct_y_from_z(self.y)
+        self._construct_y_from_z(3)
+
+    def _construct_y(self):
+        self._y = self.x + 3
+
+    @property
+    def x(self):
+        return self._x
+
+    @property
+    def y(self):
+        return self._y
+
+    def _construct_y_from_z(self, z : 'int | float'):
+        self._y = self._x + z

tests/epyccel/classes/classes_9.py

@@ -0,0 +1,23 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, missing-class-docstring
+from pyccel.decorators import inline
+
+class A:
+    def __init__(self, x : float):
+        self._x = x
+        self._y = self._calculate_y(2)
+
+    @property
+    def x(self):
+        return self._x
+
+    @inline
+    def _calculate_y(self, n : int):
+        return self.x + n
+
+    def get_A_contents(self):
+        return self.x, self.y
+
+    @inline
+    @property
+    def y(self):
+        return self._y

tests/epyccel/test_epyccel_classes.py

@@ -210,6 +210,27 @@ def test_classes_6(language):
     assert p_py.get_attributes(3) == p_l.get_attributes(3)
     assert p_py.get_attributes(4.5) == p_l.get_attributes(4.5)
 
+def test_classes_8(language):
+    import classes.classes_8 as mod
+    modnew = epyccel(mod, language = language)
+
+    a_py = mod.A(3.0)
+    a_l = modnew.A(3.0)
+
+    assert a_py.x == a_l.x
+    assert a_py.y == a_l.y
+
+def test_classes_9(language):
+    import classes.classes_9 as mod
+    modnew = epyccel(mod, language = language)
+
+    a_py = mod.A(3.0)
+    a_l = modnew.A(3.0)
+
+    assert a_py.get_A_contents() == a_l.get_A_contents()
+    assert a_py.x == a_l.x
+    assert a_py.y == a_l.y
+
 def test_generic_methods(language):
     import classes.generic_methods as mod
     modnew = epyccel(mod, language = language)