Allow allocatable function outputs and/or intent(out)

[krystophny]

Currently, allocatable and pointer output arguments are not wrapped due to memory safety reasons. This would be required in particular for factory methods in the context of abstract base classes #41.

@jameskermode do you have an idea how much effort implementation of allocatable output arguments would mean?

Probably not too bad. The reason it's not supported is because of the risk of memory leaks when memory is allocated in Fortran but would need to be freed from Python. One solution would be not to return the allocatable output argument directly, but instead wrap it in a Python class with a destructor that frees the Fortran-allocated memory when the Python object goes out of scope.

Originally posted by @jameskermode in #41 (comment)

[krystophny]

Testing now in https://github.com/itpplasma/f90wrap/tree/issue227_allocatable .

The test function is

function alloc_output_func(val) result(out)
    real, intent(in) :: val
    type(alloc_output_type), allocatable :: out
    allocate(out)
    out%a = val
end function alloc_output_func

The generated wrapper is

subroutine f90wrap_alloc_output__alloc_output_func(ret_out, val)
   ...
    allocate(ret_out_ptr%p)
    ret_out_ptr%p = alloc_output_func(val=val)
    ret_out = transfer(ret_out_ptr, ret_out)
end subroutine f90wrap_alloc_output__alloc_output_func

The type finaliser is

subroutine f90wrap_alloc_output__alloc_output_type_finalise(this)
   ...
    this_ptr = transfer(this, this_ptr)
    deallocate(this_ptr%p)
end subroutine f90wrap_alloc_output__alloc_output_type_finalise

which is correctly used by the Python wrapper

    def __del__(self):
        """
        Destructor for class Alloc_Output_Type
        ...
        """
        if self._alloc:
            _itest.f90wrap_alloc_output__alloc_output_type_finalise(this=self._handle)

So in the case of a function returning an allocatable derived type, the deallocation works out of the box. The extra allocate inside the wrapper is not necessary, but also not a problem, since standard Fortran should de-/reallocate on assignment, and no memory leak is generated. I check now the consequences for arrays too.

@jameskermode would that mean that one could allow allocatable derived types as function results right away and remove the extra allocate in a future feature within code generation?