Si tengo una matriz asignable de un tipo derivable finalizable, ¿se llamará al finalizador en cada elemento individual cuando la matriz se salga del alcance?

Aquí hay un pequeño ejemplo de código que ilustra la pregunta:

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

Tenga en cuenta que este programa pierde eldontLeakMe matriz asignada en elNew() método deLeakyType. Al principio esto fue un poco sorprendente para mí, pero luego descubrí que el problema se puede solucionar declarando el finalizadorelemental. Tanto gfortran como ifort se comportan de la misma manera, por lo que supongo que este comportamiento sigue el estándar Fortran 2003.

¿Alguien puede confirmar esto? Para ser sincero, me cuesta mucho entender lo que dice la norma sobre este punto en particular.

En este momento tampoco puedo ver mucho uso enno declarando todos mis finalizadores elementales. ¿Esto tiene alguna aplicación que estoy pasando por alto?