Fix renamed function lookup (pyccel#1914)

`FunctionDef` objects are annotated during the first `FunctionCall`
where they are used. At this point they have not been renamed if there
are name conflicts. Both the original and the collisionless name should
therefore be used to locate the `FunctionDef`. The original name will
retrieve the syntactic object while the collisionless name will retrieve
the renamed function. Fixes pyccel#1913

Author: EmilyBourne

CHANGELOG.md

@@ -40,6 +40,7 @@ All notable changes to this project will be documented in this file.
 -   Link and mention `devel` branch, not `master`.
 -   #1047 : Print the value of an unrecognised constant.
 -   #1903 : Fix memory leak when using type annotations on local variables.
+-   #1913 : Fix function calls to renamed functions.
 
 ### Changed
 

pyccel/errors/messages.py

@@ -21,7 +21,7 @@
                               "#$ header function FUNC_NAME(ARG_TYPES) results(RESULT_TYPES)\n")
 
 INCOMPATIBLE_TYPES = 'Incompatible types'
-INCOMPATIBLE_TYPES_IN_ASSIGNMENT = "Variable has already been defined with type '{}'. Type '{}' in assignment is incompatible"
+INCOMPATIBLE_TYPES_IN_ASSIGNMENT = "Object has already been defined with type '{}'. Type '{}' in assignment is incompatible"
 INCOMPATIBLE_REDEFINITION = 'Incompatible redefinition'
 INCOMPATIBLE_REDEFINITION_STACK_ARRAY = 'Cannot change shape of stack array, because it does not support memory reallocation. Avoid redefinition, or use standard heap array.'
 STACK_ARRAY_DEFINITION_IN_LOOP = 'Cannot create stack array in loop, because if does not support memory reallocation. Create array before loop, or use standard heap array.'

pyccel/parser/base.py

@@ -295,13 +295,26 @@ def blocking(self):
         return self._blocking
 
     def insert_function(self, func):
-        """."""
+        """
+        Insert a function into the current scope.
+
+        Insert a function into the current scope under the final name by which it
+        will be known in the generated code.
+
+        Parameters
+        ----------
+        func : FunctionDef | SympyFunction | Interface | FunctionAddress
+            The function to be inserted into the scope.
+        """
 
         if isinstance(func, SympyFunction):
             self.insert_symbolic_function(func)
         elif isinstance(func, (FunctionDef, Interface, FunctionAddress)):
             container = self.scope.functions
-            container[func.name] = func
+            if func.pyccel_staging == 'syntactic':
+                container[self.scope.get_expected_name(func.name)] = func
+            else:
+                container[func.name] = func
         else:
             raise TypeError('Expected a Function definition')
 

pyccel/parser/semantic.py

@@ -1214,8 +1214,9 @@ def _annotate_the_called_function_def(self, old_func, function_call_args=None):
         # Set the Scope to the FunctionDef's parent Scope and annotate the old_func
         self._scope = sc
         self._visit_FunctionDef(old_func, function_call_args=function_call_args)
+        new_name = self.scope.get_expected_name(old_func.name)
         # Retreive the annotated function
-        func = self.scope.find(old_func.name, 'functions')
+        func = self.scope.find(new_name, 'functions')
         # Add the Module of the imported function to the new function
         if old_func.is_imported:
             mod = old_func.get_direct_user_nodes(lambda x: isinstance(x, Module))[0]
@@ -1227,12 +1228,12 @@ def _annotate_the_called_function_def(self, old_func, function_call_args=None):
         # Remove the old_func from the imports dict and Assign the new annotated one
         if old_func.is_imported:
             scope = self.scope
-            while old_func.name not in scope.imports['functions']:
+            while new_name not in scope.imports['functions']:
                 scope = scope.parent_scope
-            assert old_func is scope.imports['functions'].get(old_func.name)
-            func = func.clone(old_func.name, is_imported=True)
+            assert old_func is scope.imports['functions'].get(new_name)
+            func = func.clone(new_name, is_imported=True)
             func.set_current_user_node(mod)
-            scope.imports['functions'][old_func.name] = func
+            scope.imports['functions'][new_name] = func
         return func
 
     def _create_variable(self, name, class_type, rhs, d_lhs, arr_in_multirets=False):
@@ -1592,7 +1593,14 @@ def _ensure_inferred_type_matches_existing(self, class_type, d_var, var, is_auga
         # TODO improve check type compatibility
         if not isinstance(var, Variable):
             name = var.name
-            errors.report(INCOMPATIBLE_TYPES_IN_ASSIGNMENT.format(type(var), class_type),
+            message = INCOMPATIBLE_TYPES_IN_ASSIGNMENT.format(type(var), class_type)
+            if var.pyccel_staging == "syntactic":
+                new_name = self.scope.get_expected_name(name)
+                if new_name != name:
+                    message += '\nThis error may be due to object renaming to avoid name clashes (language-specific or otherwise).'
+                    message += f'The conflict is with "{name}".'
+                    name = new_name
+            errors.report(message,
                     symbol=f'{name}={class_type}',
                     bounding_box=(self.current_ast_node.lineno, self.current_ast_node.col_offset),
                     severity='fatal')
@@ -2053,8 +2061,7 @@ def _visit_Module(self, expr):
 
             self.scope = mod_scope
 
-        for f in self.scope.functions.copy():
-            f = self.scope.functions[f]
+        for f in self.scope.functions.copy().values():
             if not f.is_semantic and not isinstance(f, InlineFunctionDef):
                 assert isinstance(f, FunctionDef)
                 self._visit(f)
@@ -3731,7 +3738,7 @@ def _visit_FunctionDef(self, expr, function_call_args=None):
 
         existing_semantic_funcs = []
         if not expr.is_semantic:
-            self.scope.functions.pop(expr.name, None)
+            self.scope.functions.pop(self.scope.get_expected_name(expr.name), None)
         elif isinstance(expr, Interface):
             existing_semantic_funcs = [*expr.functions]
             expr                    = expr.syntactic_node

tests/epyccel/modules/function_call_before_definition_2.py

@@ -1,9 +1,16 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring
 def f():
-    return g()
+    return g() + do()
 
 def g():
     return 2
 
+def do():
+    return 3
+
+def do_0001():
+    return 4
+
+
 a = f()
 

tests/errors/semantic/blocking/GENERATED_NAME_COLLISION.py

@@ -0,0 +1,13 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring
+
+def f():
+    do_0001 = 5
+    return g() + do() + do_0001
+
+def g():
+    return 2
+
+def do():
+    return 4
+
+a = f()