Fuzzer: add ability to run the generated programs

Add tests for moving nullary functions

I believe this was fixed by marijn recently.

Closes #922

Un-xfail various tests

Un-xfail-fast run-pass/send-iloop

Remove a spurious error pattern from run-pass/linked-failure

Un-xfail two tests under check-fast

Closes #937. Fixed by majick.

Revert "xfail some tests that hang (instead of segfaulting) since eafb6789a2"

This reverts commit 5f44a1356e2b0adce5157f5e331ab9a55e891b0a.

Issue #936

Check for the correct exit code on cfail tests. Closes #938

Build tuples in two phases to avoid cleaning up partial tuples

Register tuple cleanups after the tuple is built

Issue #936

Revert "Revert "xfail some tests that hang (instead of segfaulting) since eafb6789a2""

This reverts commit 6eabe6f3f4b80e8c96286e266db64dfd0e576963.

Revert "Check for the correct exit code on cfail tests. Closes #938"

This reverts commit c42401ebbc82d319c3003088db47f825d65fb9f7.

Revert "xfail some tests that hang (instead of segfaulting) since eafb6789a2"

This reverts commit 5f44a1356e2b0adce5157f5e331ab9a55e891b0a.

Issue #936

Check for the correct exit code on cfail tests. Closes #938

Break fold's circular reference during unwinding

This converts the AST fold into a resource that breaks it's own circular
reference (just a temporary workaround until GC), so that failure during fold
will unwind correctly.

Issue #936

Simplify perf target flags. Apparently the event names aren't stable/portable.

Build records in two phases to avoid cleanups on partial records

Don't register record cleanups until the record is built

rt: Introduce a self-describing box representation and functions to create and free them

xfail some tests that hang (instead of segfaulting) since eafb6789a2

See issue #936

Stop creating function pairs for static functions

These are now called directly. When taking their value, a null pointer is added
to create a pair.

Add a precondition to GEP_tup_like

Add a type_is_tup_like predicate that takes a block ctxt, and make some fns pure

In trans, replace another impossible case with a precondition

Make move-mode arguments unwind correctly. Closes #939

Dead code elim

Add a constraint on trans::type_of_fn_from_ty

And change callers appropriately.

Add a returns_non_ty_var predicate

which just calls non_ty_var on the return type of t, assuming t is
a function type.

Make ty_fn_ret pure and get rid of a duplicate function

Work around an apparent compiler bug to make my patch run

Without this, it would fail when optimization is turned on. The result of
the Load(bcx, llclosure) call would end up in llenv in a corrupted form.

Saner approach to lvalues and callable values in trans

LValues no longer carry information about generics and objs, instead
there's an extended form of lvalue, lval_maybe_callee, only used by
call and bind, which holds this info.

This makes it possible to take the value of a method and get a working
closure, and will (with some more work) allow us to call statically
known functions without loading from their pair.

Closes #435
Closes #758

Revert "Revert "Make option::get return the option contents by reference" due to memory corruption"

This reverts commit d1c27ba9e06e08e1dc27b493144e467d0efd526c.

Un-xfail some task-comm tests

Yield after send

Add non_ty_var precondition for type_of_fn, plus minor cleanup

rt: Add a new rust_box structure to the runtime that describes a self-describing box

rt: Rename rust_box to rust_box_legacy, as they're about to become self-describing

Fuzzer: update lists of known bugs

Handle the case where a child task tries to kill a parent while it is dying

Still looks pretty racy

Revert "Saner approach to lvalues and callable values in trans"

This reverts commit 66153436c9070386786c8a38cde199b5d3e71289.

Require body of else-less if expressions to be a value-less block

For consistency with other constructs that could not possibly return a
value (say, loops).

Saner approach to lvalues and callable values in trans

LValues no longer carry information about generics and objs, instead
there's an extended form of lvalue, lval_maybe_callee, only used by
call and bind, which holds this info.

This makes it possible to take the value of a method and get a working
closure, and will (with some more work) allow us to call statically
known functions without loading from their pair.

Closes #435
Closes #758

Move expr_uniq case in trans to a saner place

Note that unique pointers are still broken in more ways than I can count.

Remove autoderef for calls

We were only using it in a single place, and there for no discernable reason
(probably as part of the bare-fn-vals-are-not-copyable plan). It seems more
surprising than useful.

Remove unused method_ty field from lval_result

Clean up (and optimize) root-mutability analysis in alias.rs

Change convention for specifying referenced argument

It is now 1-based, rather than 0 based. (Seems more natural, and allows 0 to
be used to refer to self and maybe to closure.)

Also allows non-referenced args to be implicitly copied again.

Issue #918

Actually call unreachable() in impossible case in type_of_inner

Added non_ty_var precondition to trans::type_of_inner

This allows us to legitimately call unreachable() in the ty_var case.

Add parens, as needed, around else-if conditions.

Added an extra check in trans_alt

Gratuitous right now, but I'm going to change the type of trans::type_of

Added more predicates in trans

Added the non_ty_var predicate (soon to be used)
Added a check in get_res_dtor (will be necessary for a future change
to type_of_fn)
Removed a gratuitous ret

Change a few span_fatals to span_err

Add unreachable() fn, also nitpicking

Update README slightly.

Begin sketching an ICU binding. Doesn't work yet.

rt: Add libunwind.h support on Mac OS X

Revert "Make option::get return the option contents by reference" due to memory corruption

This reverts commit fc0bf125168ec3df75bc57c250a62d3ea225a546.

Make option::get return the option contents by reference

I can't believe this actually works!

Add regression tests for previously ambiguous syntactic forms

Prevent binary expressions from parsing when lhs is non-value block

Register new snapshot

Generalize expression roots in alias analysis

This allows calls-returning-a-reference to count as expression roots,
making it possible to return the result of such a call by reference.

Issue #918

Add tests for returning by reference

Issue #918

Require the parameter that will be referenced to be noted

Issue #918

Overhaul alias-checking of blocks

The set of active bindings has to be updated as by-reference locals are
encountered.

Issue #918

Make storing returned references in a by-reference local work

    fn f(a: {x: str}) -> &str {
        ret a.x;
    }

    fn main() {
        let x = {x: "hi"};
        let &y = f(x); // Look ma, no copy!
        log_err y;
    }

Issue #918.

Forbid assignment to by-reference bindings

Issue #918

Make trans understand by-ref bindings

Issue #918

Implement basic checking of by-reference bindings

Issue #918

Move local numbering into ast_map.rs

This further simplifies the alias pass, which is sorely needed.

Add representation for by-ref let bindings

Issue #918

Ensure parens are wrapped around composite exprs in call/index/field pos

This is needed to fix the second example in issue #919

More thorough check for (.. 10).x in pretty-printer

Closes #919

Stop mentioning tail calls in reference

They don't work, and won't work in the near future.

Also handle fail and put in print_maybe_parens_discrim

Closes #920

Remove maybe_protect_block kludge from pretty-printer

It is no longer needed.

Introduce new semicolon rules

- Loop bodies and resource constructors aren't allowed to have
  trailing expressions anymore.

- An expression that ends* in a block without trailing expression can
  can not be called, indexed, or subscripted.

- Only expression-statements that end* in a block without trailing
  expression can omit their semicolon.

*) 'Ending in a trailing expression' is defined as being a block or
   construct-ending-in-a-block (if, alt) that either ends in an
   expression itself, or ends in another block-like expression that
   has a trailing expression (by these same rules).

Insert omitted semicolons for statements

xfail-fast run-pass/linked-failure.rs. Not sure what the problem is.

Unsupervise tasks before the scheduler kills them. Unblock before yield->fail

Add a run-pass test for linked failure

Make failure propagation to dead parents work

The failure will basically go 'through' the dead parent and continue
propagating the failure (as if the child was reparented).

Remove mention of port, chan and task *types*, as they're not just library-provided. Move some text about channels into the comm section.

Remove talk of 'sharing boxes between tasks', old GC layer, etc. Add description of unique boxes.

Remove mention of the nonexistent (and no longer implementable) memory accounting model.

Make linked task failure work again

Fix vector indexing notation, remove reference to 'slices'.

Fix description of tuples.

Remove more references to reflection from docs

Remove description of nonexistent stuff (reflection, meta directives); add description of attributes and tidy up description of syntax extensions.

Remove stuff that's either unimplemented or misleading.

Remove misleading details.

Add another XFAILed test for failing destructors

Add another unwind test

This makes sure that cleanups added after the first invoke in a scope are
actually run on unwind

Revert "Try a little harder to avoid creating new landing pads"

This reverts commit b8e31ac46917edcf5922f0b191c5e6c4505830d2.

Conflicts:

src/comp/middle/trans.rs

Add syntax and representation for return-by-mutably-rooted-ref

This will be used in the near future to decide what can safely
be done with the returned reference.

Issue #918

Prevent memory errors when returning references to temp args.

Issue #918

Accept returning refs rooted in an arg from a by-ref funtion

Issue #918

Make ast_map.rs index function args, switch it over to simple_visitor