Assignment with polymorphic members

[Jacob_Williams]

I'm wondering if the following is a compiler bug or I'm doing something non-standard.  If I have a variable that is a type that contains polymorphic types, can I use an "=" assignment statement to set one equal to the other?  It works for scalars, but not for vectors.  If the vector is non-allocatable, then the assignment triggers an access violation.  If the vector is allocatable, then the assignment deallocates the vector.  If the type does not contain a polymorphic entity, then everything works fine.  See example below.

[fortran]

!*******************************************************************************************************
    module test_module
!*******************************************************************************************************
    
    implicit none
    
    private
    
    type,public :: atype
        integer :: i = 1
    end type atype
    type,extends(atype),public :: ctype
        integer :: k = 3
    end type ctype
    
    type,public :: my_type
        integer,dimension(:),allocatable    :: ivec
        class(atype),allocatable            :: abc
    end type my_type
    
    public :: test_routine_1,test_routine_2,test_routine_3
    
    contains
!*******************************************************************************************************

!******************************************************************    
    subroutine test_routine_1()
!******************************************************************    
    implicit none
    
    type(my_type) :: r1,r2
        
    !---scalar version:
    
    allocate(r1%ivec(2))
    allocate( ctype :: r1%abc )
        
    r2 = r1        !This works
    
    write(*,*) ''
    write(*,*) ' scalar version '
    write(*,*) 'allocated(r2%ivec)    ', allocated(r2%ivec)            !T
    write(*,*) 'allocated(r2%abc)     ', allocated(r2%abc)            !T

!******************************************************************    
    end subroutine test_routine_1    
!******************************************************************    
    
!******************************************************************    
    subroutine test_routine_2()
!******************************************************************    
    implicit none
    
    type(my_type),dimension(2) :: seg
        
    !---vector version (nonallocatable):

    allocate(seg(1)%ivec(2))
    allocate( ctype :: seg(1)%abc )
    
    write(*,*) ''
    write(*,*) ' vector version (nonallocatable) '
    write(*,*) 'allocated(seg(1)%ivec) ', allocated(seg(1)%ivec)    !T
    write(*,*) 'allocated(seg(2)%ivec) ', allocated(seg(2)%ivec)    !F
    
    seg(2) = seg(1)                                                !crash due to access violation!!!
        
    write(*,*) ''
    write(*,*) 'allocated(seg(1)%ivec) ', allocated(seg(1)%ivec)
    write(*,*) 'allocated(seg(2)%ivec) ', allocated(seg(2)%ivec)

!******************************************************************    
    end subroutine test_routine_2        
!******************************************************************    
    
!******************************************************************    
    subroutine test_routine_3()
!******************************************************************    
    implicit none
    
    type(my_type),dimension(:),allocatable :: seg
        
    !---vector version (allocatable):

    allocate(seg(2))

    allocate(seg(1)%ivec(2))
    allocate( ctype :: seg(1)%abc )
    
    write(*,*) ''
    write(*,*) ' vector version (allocatable) '
    write(*,*) 'allocated(seg)         ', allocated(seg)            !T
    write(*,*) 'allocated(seg(1)%ivec) ', allocated(seg(1)%ivec)    !T
    write(*,*) 'allocated(seg(2)%ivec) ', allocated(seg(2)%ivec)    !F
    
    seg(2) = seg(1)                                                    !This is deallocating the seg array!!!
        
    write(*,*) ''
    write(*,*) 'allocated(seg)         ', allocated(seg)            !F
    write(*,*) 'allocated(seg(1)%ivec) ', allocated(seg(1)%ivec)    !crash due to access violation!!!
    write(*,*) 'allocated(seg(2)%ivec) ', allocated(seg(2)%ivec)

!******************************************************************    
    end subroutine test_routine_3    
!******************************************************************    
    
!*******************************************************************************************************
    end module test_module
!*******************************************************************************************************
    
!*******************************************************************************************************
    program main
!*******************************************************************************************************
    use test_module
    
    call test_routine_1()    !OK
    call test_routine_2()    !crash
    call test_routine_3()    !crash
    
!*******************************************************************************************************
    end program main
!*******************************************************************************************************

[/fortran]

[Steven_L_Intel1]

I don't see any errors with this code. It builds and runs ok for me in 14.0. You don't even need /standard-semantics here.

  scalar version
 allocated(r2%ivec)     T
 allocated(r2%abc)      T

  vector version (nonallocatable)
 allocated(seg(1)%ivec)  T
 allocated(seg(2)%ivec)  F

 allocated(seg(1)%ivec)  T
 allocated(seg(2)%ivec)  T

  vector version (allocatable)
 allocated(seg)          T
 allocated(seg(1)%ivec)  T
 allocated(seg(2)%ivec)  F

 allocated(seg)          T
 allocated(seg(1)%ivec)  T
 allocated(seg(2)%ivec)  T

[Jacob_Williams]

Interesting... Here is a zipped version of my project.  I get access violations for both the Debug and Release builds.  I'm using a Windows 7 64 bit machine, using Visual Studio 2010 and the 32 bit version of the 14.0 Intel compiler.

[Steven_L_Intel1]

I'm actually using a pre-release version of Update 1, so it's possible we fixed a problem between the initlal 14.0 and the update. I can't test the older version right away, so I suggest just waiting for Update 1 (shouldn't be more than a few days.)

[Jacob_Williams]

No problem!  I can wait.  So, the code is standard-conforming? (The polymorphic element should be automatically allocated to the correct type when using "=")?

[IanH]

Your understanding of what should happen is correct, and the code looks ok to me from a cursory examination.  I've been informed previously (it might have been by Steve on this forum or perhaps it was via premier support) that there are fixes in the October update that would address issues with similar characteristics to what you've encountered.

[Steven_L_Intel1]

I saw nothing wrong with the code. Amd I just now tried it with the September release and it indeed fails.

[Jacob_Williams]

The bug is indeed fixed in v2013 SP1 Update 1.

[Steven_L_Intel1]

Glad to hear it.