Deallocation of allocatable class components of types

Consider this:

    module memory
    implicit none

    Type :: MyType
        real X(50000)
    end type

    type M
        class(MyType), allocatable :: mem
    contains 
!    final :: testfree
    end type
    contains

!    subroutine testfree(this)
!    Type(M) this
!    if (allocated(this%mem)) deallocate(this%mem)
!    end subroutine testfree

    subroutine local(A)
    Type (M) :: A, B

    B=A

    end subroutine local

    subroutine testmem
    Type(M) :: X
    integer i

    allocate(MyType::X%mem)
    do i=1, 1000
        call local(X)
    end do

    end subroutine testmem

    end module memory

My understanding is that allocatable components of types are supposed to be deep copied and deallocated automatically as appropriate. However calling "testmem" when compiled wtih ifort gives a memory leak, which can be fixed by uncommenting the explicit final. What exactly are the rules here, or is it a compiler bug? (changing the component to a Type rather than Class there is no leak).