The first try, with work-in-progress artifacts
Removing the work-in-progress artifacts (comments, printouts)
Futurize types/records/sungeun/chapelTypes/record_range
Also reorder in CallInfo data
Remove debugging support
Fixing some things, adding some comments based on Michaels suggestions.
Adding makefile changes to compile the curl plugin with CC instead of CXX (thanks Michael!)
Fix some tests in types/records/sungeun

Updated classInRecord.good to match the behavior on the branch.  Examining the source
code, it appears that it is correct for the default-constructor of myR to be called even
when no initializer is provided in the declaration.  That means "c = new myC();" will
always be called when a record is initialized.  Hence, no cases remain where the "c" field
in a myR record can initially be nil.  The revised .good file shows that the "c" field is
now always (correctly) initialized.

Futurized the test case constructor2.  Normalization currently converts declaration
constructs that are intended to represent copy-initialization with default-initialization
followed by assignment.  Details appear in the added .future file.  Fixing the underlying
problem is well beyond the scope of the current effort.
Merge branch 'future-writef-with-var-pattern' of https://github.com/thomasvandoren/chapel
Polish: removed references to "wrapper"; made the function return void"
Add missing writef(fmt:string) versions.
Un-futurize Thomas' test.
Adding fixes per Michael's suggestions. Cleaned up qio_get_chunk, and moved qio_get_fs_type above it (since we are now using it in the qio_get_chunk function
Adding user facing version of openurl(), also added openreader() and openwriter()
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.
Handle type variables in a few special places

-- when codegenning a VarSymbol with FLAG_TYPE_VARIABLE
   in LLVM, return the type (and not a value)
-- when doing a PRIM_MOVE in codegen, if the LHS is a type variable,
   do nothing
update externCResolve to not use module initFn

module init fns were removed recently, so
we just add global variables to the module's block
instead.