Remove use of ndarrays when returning arrays from Fortran functions (pyccel#1968)

Remove the use of ndarray_t in the C wrapper of a function translated to
Fortran returning arrays. Fixes
pyccel#1967 , making it easier to
remove ndarray_t later and reducing complexity.

The functions `_wrap_FunctionDefResult` and
`_wrap_BindCFunctionDefResult` are modified to return a dictionary with
the useful information that they calculate. In addition to the body
returned previously the function result arguments are additionally
returned. This makes it easier to pass multiple variables to the
function and simplifies `_wrap_FunctionDef` slightly.

The new `PyArray` constructing function `to_pyarray` fixes the memory
leak identified in pyccel#1180 .

**Commit Summary**
- Add an `is_alias` property to `FunctionCall` which identifies if the
returned object is a pointer.
- Fix a bug in `convert_to_literal` where booleans were converted to
integers (because `isinstance(True, int)` returns true)
- Add a new `to_pyarray` function to build a `PyArray` from a data
pointer and a stack array of shapes
- Use `var` to avoid the repetition of `expr.variable` in
`CCodePrinter_print_Declare`
- Ensure `Declare.value` is used in C code.
- Allow CStackArray objects to be declared
- Initialise local `void*` variables to `NULL` (fixes macosx warnings)
- Create `CToPythonWrapper._call_wrapped_function` to reduce code
duplication
- Use variables as keys to `FunctionDef.result_pointer_map` instead of
`FunctionDefResult` objects. This ensures that the map can also be used
in `CToPythonWrapper` when translating to Fortran
- Return a dictionary from `_wrap_FunctionDefResult` and
`_wrap_BindCFunctionDefResult` to improve readability and code locality
- Determine whether the returned array may need deallocating by Python
(this should be the case unless the result is a pointer to an argument
or is stored in a class).
- Add `capsule_cleanup` function to ensure that arrays created by Pyccel
and returned will be freed (fixes memory leak).

Author: EmilyBourne

CHANGELOG.md

@@ -85,6 +85,7 @@ All notable changes to this project will be documented in this file.
 -   \[INTERNALS\] Rename `_visit` functions called from a `FunctionCall` which don't match the documented naming pattern to `_build` functions.
 -   \[INTERNALS\] Remove unnecessary argument `kind` to `Errors.set_target`.
 -   \[INTERNALS\] Handle STC imports with Pyccel objects.
+-   \[INTERNALS\] Stop using ndarrays as an intermediate step to return arrays from Fortran code.
 
 ### Deprecated
 

pyccel/ast/core.py

@@ -2055,6 +2055,16 @@ def interface_name(self):
         """
         return self._interface_name
 
+    @property
+    def is_alias(self):
+        """
+        Check if the result of the function call is an alias type.
+
+        Check if the result of the function call is an alias type.
+        """
+        assert len(self._funcdef.results) == 1
+        return self._funcdef.results[0].var.is_alias
+
     def __repr__(self):
         args = ', '.join(str(a) for a in self.args)
         return f'{self.func_name}({args})'

pyccel/ast/cwrapper.py

@@ -30,7 +30,7 @@
 
 from .internals import PyccelFunction
 
-from .literals  import LiteralString, LiteralInteger
+from .literals  import LiteralString, LiteralInteger, Nil
 
 from .variable  import Variable
 
@@ -926,7 +926,8 @@ def declarations(self):
 
         Returns the declarations of the variables.
         """
-        return [Declare(v, static=(v in self._static_vars)) \
+        return [Declare(v, static=(v in self._static_vars),
+                        value = (Nil() if isinstance(v.class_type, (VoidType, BindCPointer)) else None)) \
                 for v in self.scope.variables.values()]
 
 #-------------------------------------------------------------------

pyccel/ast/literals.py

@@ -451,14 +451,14 @@ def convert_to_literal(value, dtype = None):
 
     # Calculate the default datatype
     if dtype is None:
-        if isinstance(value, int):
+        if isinstance(value, bool):
+            dtype = PythonNativeBool()
+        elif isinstance(value, int):
             dtype = PythonNativeInt()
         elif isinstance(value, float):
             dtype = PythonNativeFloat()
         elif isinstance(value, complex):
             dtype = PythonNativeComplex()
-        elif isinstance(value, bool):
-            dtype = PythonNativeBool()
         elif isinstance(value, str):
             dtype = StringType()
         else:

pyccel/ast/numpy_wrapper.py

@@ -18,7 +18,7 @@
 from .core              import FunctionDef
 from .core              import FunctionDefArgument, FunctionDefResult
 
-from .c_concepts        import CNativeInt
+from .c_concepts        import CNativeInt, CStackArray
 
 from .numpytypes        import NumpyInt8Type, NumpyInt16Type, NumpyInt32Type, NumpyInt64Type
 from .numpytypes        import NumpyFloat32Type, NumpyFloat64Type, NumpyFloat128Type
@@ -152,6 +152,18 @@ def get_numpy_max_acceptable_version_file():
                                                  FunctionDefArgument(Variable(PyccelPyObject(), name = 'obj', memory_handling='alias'))],
                                     results   = [FunctionDefResult(Variable(CNativeInt(), name = 'd'))])
 
+to_pyarray = FunctionDef(name = 'to_pyarray',
+                         body = [],
+                         arguments = [FunctionDefArgument(Variable(CNativeInt(), name = 'nd')),
+                                      FunctionDefArgument(Variable(CNativeInt(), name = 'typenum')),
+                                      FunctionDefArgument(Variable(VoidType(), name = 'data', memory_handling='alias')),
+                                      FunctionDefArgument(Variable(CStackArray(NumpyInt64Type()), 'shape')),
+                                      FunctionDefArgument(Variable(PythonNativeBool(), 'c_order')),
+                                      FunctionDefArgument(Variable(PythonNativeBool(), 'release_memory'))],
+                         results = [FunctionDefResult(Variable(PyccelPyObject(), name = 'arr', memory_handling='alias'))]
+                         )
+
+
 import_array = FunctionDef('import_array', (), (), ())
 
 # Basic Array Flags

pyccel/codegen/printing/ccode.py

@@ -9,6 +9,8 @@
 
 from pyccel.ast.basic     import ScopedAstNode
 
+from pyccel.ast.bind_c    import BindCPointer
+
 from pyccel.ast.builtins  import PythonRange, PythonComplex
 from pyccel.ast.builtins  import PythonPrint, PythonType
 from pyccel.ast.builtins  import PythonList, PythonTuple, PythonSet, PythonDict
@@ -57,6 +59,7 @@
 from pyccel.ast.variable import InhomogeneousTupleVariable
 
 from pyccel.ast.c_concepts import ObjectAddress, CMacro, CStringExpression, PointerCast, CNativeInt
+from pyccel.ast.c_concepts import CStackArray
 
 from pyccel.codegen.printing.codeprinter import CodePrinter
 
@@ -1342,6 +1345,8 @@ def get_declare_type(self, expr):
             if isinstance(expr.class_type, (HomogeneousSetType, HomogeneousListType, DictType)):
                 dtype = self.get_c_type(expr.class_type)
                 return dtype
+            if isinstance(expr.class_type, CStackArray):
+                return self.get_c_type(expr.class_type.element_type)
             if isinstance(expr.class_type,(HomogeneousTupleType, NumpyNDArrayType)):
                 if expr.rank > 15:
                     errors.report(UNSUPPORTED_ARRAY_RANK, symbol=expr, severity='fatal')
@@ -1379,20 +1384,31 @@ def _print_FuncAddressDeclare(self, expr):
         return f'{ret_type} (*{name})({arg_code});\n'
 
     def _print_Declare(self, expr):
-        if isinstance(expr.variable, InhomogeneousTupleVariable):
-            return ''.join(self._print_Declare(Declare(v,intent=expr.intent, static=expr.static)) for v in expr.variable)
+        var = expr.variable
+        if isinstance(var, InhomogeneousTupleVariable):
+            return ''.join(self._print_Declare(Declare(v,intent=expr.intent, static=expr.static)) for v in var)
+
+        declaration_type = self.get_declare_type(var)
+        variable = self._print(var.name)
 
-        declaration_type = self.get_declare_type(expr.variable)
-        variable = self._print(expr.variable.name)
+        init = f' = {self._print(expr.value)}' if expr.value is not None else ''
 
-        if expr.variable.is_stack_array:
-            preface, init = self._init_stack_array(expr.variable,)
+        if isinstance(var.class_type, CStackArray):
+            assert init == ''
+            preface = ''
+            if isinstance(var.alloc_shape[0], (int, LiteralInteger)):
+                init = f'[{var.alloc_shape[0]}]'
+            else:
+                declaration_type += '*'
+                init = ''
+        elif var.is_stack_array:
+            preface, init = self._init_stack_array(var,)
         elif declaration_type == 't_ndarray' and not self._in_header:
+            assert init == ''
             preface = ''
             init    = ' = {.shape = NULL}'
         else:
             preface = ''
-            init    = ''
 
         external = 'extern ' if expr.external else ''
         static = 'static ' if expr.static else ''
@@ -2023,7 +2039,8 @@ def _print_FunctionDef(self, expr):
             self._additional_args.append(results)
 
         body  = self._print(expr.body)
-        decs  = [Declare(i) if isinstance(i, Variable) else FuncAddressDeclare(i) for i in expr.local_vars]
+        decs = [Declare(i, value=(Nil() if i.is_alias and isinstance(i.class_type, (VoidType, BindCPointer)) else None))
+                if isinstance(i, Variable) else FuncAddressDeclare(i) for i in expr.local_vars]
 
         if len(results) == 1 :
             res = results[0]

pyccel/codegen/printing/cwrappercode.py

@@ -501,14 +501,16 @@ def _print_Declare(self, expr):
 
             variable = self._print(expr.variable.name)
 
+            init = f' = {self._print(expr.value)}' if expr.value is not None else ''
+
             if var.rank == 0:
-                return f'{static}{external}{declaration_type} {variable};\n'
+                return f'{static}{external}{declaration_type} {variable}{init};\n'
 
             size = var.shape[0]
             if isinstance(size, LiteralInteger):
                 return f'{static}{external}{declaration_type} {variable}[{size}];\n'
             else:
-                return f'{static}{external}{declaration_type}* {variable};\n'
+                return f'{static}{external}{declaration_type}* {variable}{init};\n'
         else:
             return CCodePrinter._print_Declare(self, expr)