The first try, with work-in-progress artifacts
Removing the work-in-progress artifacts (comments, printouts)
Also reorder in CallInfo data
Remove debugging support
Polish: removed references to "wrapper"; made the function return void"
Added a comment based on Tom's review
Merge pull request #121 from vasslitvinov/rr

Compiler/resolution: do not create order wrappers.
Instead, when needed, reorder the call actuals directly.

Order wrappers are mentioned in svn:r1358 - see ACallbacks::order_wrapper(),
and were introduced before that. We no longer know why we were not
reordering the actuals directly back then.

As to the order of any side effects that may happen while evaluating
the actuals: I believe that any side effects are flattened during
normalization into statements that preceed the CallExpr. The actuals,
I expect, are all just symbols, so it does not matter (mostly) what order
to pass them in.

I will add separately a test that highlights the evaluation order.
Its output differs from what would be produced by the rule "evaluate
the actuals in the order they appear in the call". However, the spec
does not seem to define the order of evaluating the actuals, and the
output of the test is unaffected by this change.

IMPLEMENTATION NOTES

This turned out to be a simple change.

I renamed the function and made it return void, to make it clear
that it will never create a wrapper. I left its definition and
its call in the spots where they have been, partly to preserve
history, partly because I did not see any better spots for them.

reviewed by: David, Tom
Added a test of evaluation order of the actuals.
Merge pull request #123 from vasslitvinov/add-test-of-order-of-evaluation-of-actuals

Added a test of evaluation order of the actuals.

This test documents the current state of affairs.
It does not specify the party line.

I did not see in the spec the definition of the order
in which the actuals of a function call are evaluated.
One might want to define the evaluation order to be the order
in which the actuals appear in the call.
However this is not how it is implemented right now.
In particular, in this call:

  someFunction(someVariable, someSideEffectingFunction())

someSideEffectingFunction() will be called first, before
someVariable's value is read.

One benefit of doing it this way is passing variables to functions
directly. I.e. we avoid creating argument temps in the caller.