Pure procedure and intent(out) polymorphic pointer argument

[gronki]

@ivanpribec

and as @jwmwalrus spelled out:

I mentioned that there could be a memory leak precisely because of that —the intent(out) applies to the pointer, so the target is still there, but if the target is anonymous (i.e., done through allocation of that pointer), then there’ll be no way to access it anymore.

Making a pointer became undefined means changing a descriptor. The actual type would become lost on entry. It could invalidate other variables in your program. In contrast intent inout asserts you’ll be taking control of the pointers association status and target, and and you’re fully aware how. Just one way of reasoning about this.

Can you give an example of how a type would be lost? I absolutely do not understand that reasoning. How a type would be “lost” (it would not be) and invalidate other variables (it would not?)

The more we discuss the more I think I am right.

Funnily enough, gfortran 13 does not say a word about explicit deallocation, which should be forbidden (the finalizer can be invoked).

module bugmod

   implicit none

   type value_t
   end type

contains

   pure subroutine reset_ptr(ptr)
      class(value_t), intent(inout), pointer :: ptr

      nullify(ptr)
   end subroutine

   pure subroutine dealloc_ptr(ptr)
      class(value_t), intent(inout), pointer :: ptr
      ! hey, here we might call an impure finalizer
      ! but no word from gfortran
      deallocate(ptr)
   end subroutine

end module