Minor touch-ups [reviewed by vass]

Add arguments to comments describing block info primitives.
Remove the unused bodyMarker argument from expandBodyForIteratorInline().

git-svn-id: http://svn.code.sf.net/p/chapel/code/trunk@21991 3a8e244f-b0f2-452b-bcba-4c88e055c3ca
Fix the iterator inlining memory leak bug. [reviewed by vass]

Memory was being leaked reliably in leader-follower iterators, but only if
iterator inlining is disabled or disrupted.  If the optimization which replaces
simple iterators with a tight loop fails, then we still create the iterator
class object (ic) and expect this to be cleanup up.  If it is not cleaned up,
then we leak memory.  (See test/memory/figueroa/LeakedMemory6.future.)

The mechanism for this error is that when expanding a for loop, the body of the
for loop is expanded inline wherever a yield statement occurs.  If the loop body
contains a break (or return) statement, this will cause control to jump across
the _freeIterator call that existed at the end of the original for loop, so the
_freeIterator function is never called.

The solution is quite simple.  After for loop expansion is complete, each goto
is examined to see if it is a break or return statement.  If so, then the target
of the goto is found.  Its parent is marked as the outermost scope of interest.
Starting with the goto statement itself, each containing scope is examined to
see if it contains a _freeIterator call in its suffix (i.e. after the position
where the goto appears).  If so, a copy of the _freeIterator call is inserted
just before the goto statement.  (If the goto is deeply nested, it may be the
case that several crossed _freeIterator calls are discovered and inserted.)

This fixup does not work in a zippered iterator, since the structure of the AST
does not allow us to easily determine which exit paths will be traversed before
the iterator field in the zippered iterator structure is initialized.  We
recognize that case by determining that the enclosing function is named
"advance".  In that case the fixup is not applied.  This means that zippered
iterators may still leak memory.  Probably, factoring the "advance" function
would render the current fix more effective in that context.






git-svn-id: http://svn.code.sf.net/p/chapel/code/trunk@21992 3a8e244f-b0f2-452b-bcba-4c88e055c3ca
Suppress GCC warning about being unable to inline functions. [trivial]

git-svn-id: http://svn.code.sf.net/p/chapel/code/trunk@21993 3a8e244f-b0f2-452b-bcba-4c88e055c3ca