Eu tenho um tipo derivado (wrapper) contendo um outro tipo derivado (over). Para este último, o operador de atribuição foi sobrecarregado. Como a atribuição de tipos derivados acontece por padrão, eu esperaria que atribuir duas instâncias dewrapper invocaria a atribuição sobrecarregada paraover em algum ponto. No entanto, usando o programa abaixo, não parece ser o caso. A atribuição sobrecarregada só é chamada se eu também sobrecarregar a atribuição parawrapper contendo umexplícito atribuição entre instâncias deover (descomentando as linhas de código comentadas). Por quê? Acho isso um tanto contra intuitivo. Existe alguma maneira de evitar a sobrecarga no tipo de embalagem?

module test_module
  implicit none

  type :: over
    integer :: ii = 0
  end type over

  type :: wrapper
    type(over) :: myover
  end type wrapper

  interface assignment(=)
    module procedure over_assign
    !module procedure wrapper_assign
  end interface assignment(=)

contains

  subroutine over_assign(other, self)
    type(over), intent(out) :: other
    type(over), intent(in) :: self

    print *, "Assignment of over called"
    other%ii = -1

  end subroutine over_assign

  !subroutine wrapper_assign(other, self)
  !  type(wrapper), intent(out) :: other
  !  type(wrapper), intent(in) :: self
  !
  !  other%myover = self%myover
  !
  !end subroutine wrapper_assign

end module test_module

program test
  use test_module
  implicit none

  type(wrapper) :: w1, w2

  print *, "Assigning wrapper instances:"
  w2 = w1

end program test