[Bug fortran/64952] New: Missing temporary in assignment from elemental function

["pault at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64952

            Bug ID: 64952
           Summary: Missing temporary in assignment from elemental
                    function
           Product: gcc
           Version: 5.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: fortran
          Assignee: unassigned at gcc dot gnu.org
          Reporter: pault at gcc dot gnu.org

See https://groups.google.com/forum/#!topic/comp.lang.fortran/TvVY5j3GPmg

gfortran produces wrong result from:

PROGRAM Main
    INTEGER :: i, index(5) = (/ (i, i = 1,5) /)
    REAL :: array(5) = (/ (i+0.0, i = 1,5) /)
    array = Fred(index,array)
    PRINT *, array
CONTAINS
    ELEMENTAL FUNCTION Fred (n, x)
        REAL :: Fred
        INTEGER, INTENT(IN) :: n
        REAL, INTENT(IN) :: x
        ! In general, this would be in an external procedure
        Fred = x+SUM(array(:n-1))+SUM(array(n+1:))
     END FUNCTION Fred
END PROGRAM Main

outputs
15.0000000       29.0000000       56.0000000       109.000000      214.000000   
when result should be
5*15.0

A temporary should be produced for array = Fred(index, array). See the clf
thread for the reasoning.

In a nutshell, the reason that won the day (I had another point of view) is:
    The execution of the assignment shall have the same effect as
    if the evaluation of expr and the evaluation of all expressions
    in variable occurred before any portion of the variable is
    defined by the assignment. The evaluation of expressions within
    variable shall neither affect nor be affected by the evaluation
    of expr.

Clearly, the above code violates this requirement because of the references to
'array' in 'Fred'. I think that we will have to provide an attribute that marks
up array valued elemental functions that have any external array references and
provide a temporary for assignment from one of these. Fortunately, it only
affects contained functions so that we do not have to carry it across when
using modules.

Paul