Proposal: When type1 is extended to type2, procedure pointers with (type1) passed-object dummy argument in type1, will be able to point to both procedures with type1 and procedures with type2 dummy arguments in type2. *1 in the example.
Also, procedure pointers with an extended argument should be able to point to procedures with a parent argument. *2 in the example.
This is already in the standard for type-bound procedures, the request is to do it also for procedure pointers.
module mod_type1 implicit none type :: type1 procedure(type1interface), pointer :: point1 end type interface subroutine type1interface(a) import type1 implicit none class(type1) :: a end subroutine end interface type, extends(type1) :: type2 procedure(type2interface), pointer :: point2 end type interface subroutine type2interface(a) import type2 implicit none class(type2) :: a end subroutine end interface contains subroutine type1subroutine(a) implicit none class(type1) :: a write(*,*) 'hello world' end subroutine subroutine type2subroutine(a) implicit none class(type2) :: a write(*,*) 'hello world 2' end subroutine end module program Main use mod_type1 implicit none type(type2) :: mytype2 procedure(type2subroutine), pointer :: mypointer2 procedure(type1subroutine), pointer :: mypointer1 mytype2%point1 => type1subroutine mytype2%point2 => type2subroutine mytype2%point1 => type2subroutine !*1 !THIS IS NOT CONFORMING TO THE STANDARD (PROPOSAL) mytype2%point2 => type1subroutine !*2 !THIS IS NOT CONFORMING TO THE STANDARD (PROPOSAL) mypointer2 => type1subroutine !*2 !THIS IS NOT CONFORMING TO THE STANDARD (PROPOSAL) mypointer2 => mypointer1 !*2 !THIS IS NOT CONFORMING TO THE STANDARD (PROPOSAL) call mytype2%point1 end program
The first part of the proposal breaks type safety.
Consider what happens with the code above if the call statement was replaced with:
which is legal F2003+. The passed object dummy argument will be of type type1 (that’s what the syntax object%parent means), which is not what the procedure expects.
type2subroutine doesn’t actually reference the dummy argument, and hence doesn’t reference anything about the dummy argument that is specific to the
type2 extension. In real code such a reference to components of the extended (declared) type is certainly possible, perhaps expected.)
Or, given the statements in the example program, consider:
type(type1) :: other other%point1 => mytype2%point1 ! or other = mytype2%type1 CALL other%point1