Se eu tiver uma matriz alocável de um tipo derivado finalizável, o finalizador será chamado em cada elemento individual quando a matriz ficar fora do escopo?

Aqui está um pequeno exemplo de código que ilustra a pergunta:

module LeakyTypeModule

   implicit none
   private

   type, public :: LeakyType
      real, pointer :: dontLeakMe(:) => null()
   contains
      procedure :: New
      final     :: Finalizer
   end type

contains

   subroutine New(self, n)
      class(LeakyType), intent(out) :: self
      integer         , intent(in)  :: n
      allocate(self%dontLeakMe(n))
      self%dontLeakMe = 42.0
   end subroutine

   subroutine Finalizer(self)
      type(LeakyType), intent(inout) :: self
      if (associated(self%dontLeakMe)) deallocate(self%dontLeakMe)
   end subroutine

end module


program leak

   use LeakyTypeModule
   implicit none

   type(LeakyType), allocatable :: arr(:)

   allocate(arr(1))
   call arr(1)%New(1000)
   deallocate(arr)

end program

Observe que este programa vaza odontLeakMe matriz alocada noNew() método deLeakyType. No começo, isso foi um pouco surpreendente para mim, mas descobri que o problema pode ser resolvido declarando o finalizadorelemental. O gfortran e o ifort se comportam da mesma maneira, portanto, presumo que esse comportamento esteja seguindo o padrão Fortran 2003.

alguém pode confirmar isso? Para ser sincero, tenho dificuldade em entender o que o padrão diz sobre esse ponto específico.

No momento, também não vejo muita utilidade emnão declarando todos os meus finalizadores elementares. Isso tem algum aplicativo que estou ignorando?