J3/10-160r1
To: J3
From: Malcolm Cohen
Subject: Final interp request 3.
Date: 2010 June 15

----------------------------------------------------------------------

NUMBER: F08/0013
TITLE: How does finalization interact with allocatable assignment?
KEYWORDS: Finalization
DEFECT TYPE: Erratum
STATUS: J3 consideration in progress

QUESTION:

Consider the program:

      Module m
        Type t1
          Real c
        Contains
          Final :: f11
        End Type
      Contains
        Subroutine f11(x)
          Type(t),Intent(InOut) :: x(:)
          Print *,'f11 called'
        End Subroutine
      End Module
      Program q
        Use m
        Type(t1),Parameter :: ap1(1) = [ t1(1.5) ]
        Type(t1),Parameter :: ap2(3) = [ t1(2.5),t1(3.5),t1(4.5) ]
        Type(t1),Parameter :: ap3(3) = t1(0.5)
        Type(t1),Allocatable :: x(:)
        x = ap1 ! (*1)
        x = ap2 ! (*2)
        x = ap3 ! (*3)
      End Program

The topic is how 4.5.6.3 paragraphs 1 and 9 interact.
The relevant texts are, respectively:
  "When an allocatable entity is deallocated, it is finalized."
  "When an intrinsic assignment statement is executed, the variable
   is finalized after evaluation of <expr> and before the definition
   of the variable."

In the assignment marked (*1), paragraph 9 says that the variable (X)
is finalized, i.e.
  CALL F11(X)
is executed.  However, this would be invalid, because an unallocated
allocatable would be associated with a nonallocatable nonoptional
dummy argument.

In the assignment marked (*2), paragraph 9 again says that the
variable is finalized - after evaluation of <expr> but before the
definition of the variable.  However, because the shapes of the
variable and the expression differ, definition of the variable
involves deallocating the variable (and allocating it with the correct
shape).  Paragraph 1 says that deallocating the variable finalizes it,
so that means that F11 should be called twice for the variable.  This
is problematic since a finalized entity is not permitted to be
referenced or defined by a final subroutine.

In the assignment marked (*3), the variable and expression have the
same shape so the variable will not be deallocated, so according to
paragraph 9 it should be finalized once.

Q1. Are all the assignment statements standard-conforming?

Q2. How many times is the variable finalized (i.e. how many times is
    the final subroutine called) in each standard-conforming case?

ANSWER:

A1. Yes, all the assignment statements are intended to be standard
    conforming.  Edits are supplied to correct the problem in (*1).

A2. The variable is finalized exactly once, except when it was
    unallocated (and then it is not finalized).  Edits are supplied to
    correct the problem in (*2).

EDITS:

{to 10-007}

[76:32-33] Replace entire paragraph 9 with
    "When an intrinsic assignment statement is executed, the variable
     is finalized unless it is an unallocated allocatable or would be
     deallocated because the properties of the <expr> differ from
     those of the variable (7.2.1.3).  This finalization occurs after
     evaluation of <expr> and before the definition of the variable."

SUBMITTED BY: Malcolm Cohen

HISTORY: 10-160    m192  F08/0013 Submitted
         10-160r1  m192  Revised

----------------------------------------------------------------------