Implement Show for &mut [T]
native: Unlink unix socket paths on drop

This prevents unix sockets from remaining on the system all over the place, and
more closely mirrors the behavior of libuv and windows pipes.
There are no 64-bit Windows snapshots yet, so we'll use 32-bit ones instead.
Upgrade compiler-rt
add volatile copy/copy_nonoverlapping/set

This exposes volatile versions of the memset/memmove/memcpy intrinsics.

The volatile parameter must be constant, so this can't simply be a
parameter to our intrinsics.
Added examples for parse_bytes(buf: &[u8], radix: uint) in int_macros.rs and uint_macros.rs
Removed trailing whitespace in on line 242 in int_macros.rs and on line 156 in uint_macros.rs
Fixed Win64 build
auto merge of #13687 : exscape/mut-vector-Show/master, r=alexcrichton

Removes the need for hacks to println! mutable slices, among other things.
auto merge of #13690 : alexcrichton/rust/unlink-unix-pipe, r=brson

This prevents unix sockets from remaining on the system all over the place, and
more closely mirrors the behavior of libuv and windows pipes.
auto merge of #13692 : vadimcn/rust/Win64-pre, r=alexcrichton

Stack unwinding doesn't work yet, so this won't pass a lot of tests.
auto merge of #13693 : thestinger/rust/mem, r=alexcrichton

This exposes volatile versions of the memset/memmove/memcpy intrinsics.

The volatile parameter must be constant, so this can't simply be a
parameter to our intrinsics.
auto merge of #13694 : jacob-hegna/rust/master, r=brson

... and uint_macros.rs
test: Ignore tcp-connect-timeout on freebsd

The BSD builders are failing with a different error that is not a timeout error
(Connection reset by peer), so this test isn't really all that useful on
freebsd. Due to a lack of a better idea of how to test a connect timeout, this
test is going to just be ignored for now.
auto merge of #13689 : alexcrichton/rust/ignore-tcp-connect-freebsd, r=brson

The BSD builders are failing with a different error that is not a timeout error
(Connection reset by peer), so this test isn't really all that useful on
freebsd. Due to a lack of a better idea of how to test a connect timeout, this
test is going to just be ignored for now.
rustc: Tweak the borrow on closure invocations

This alters the borrow checker's requirements on invoking closures from
requiring an immutable borrow to requiring a unique immutable borrow. This means
that it is illegal to invoke a closure through a `&` pointer because there is no
guarantee that is not aliased. This does not mean that a closure is required to
be in a mutable location, but rather a location which can be proven to be
unique (often through a mutable pointer).

For example, the following code is unsound and is no longer allowed:

    type Fn<'a> = ||:'a;

    fn call(f: |Fn|) {
        f(|| {
            f(|| {})
        });
    }

    fn main() {
        call(|a| {
            a();
        });
    }

There is no replacement for this pattern. For all closures which are stored in
structures, it was previously allowed to invoke the closure through `&self` but
it now requires invocation through `&mut self`.

The standard library has a good number of violations of this new rule, but the
fixes will be separated into multiple breaking change commits.

Closes #12224

[breaking-change]
std: Change RandomAccessIterator to use `&mut self`

Many iterators go through a closure when dealing with the `idx` method, which
are invalid after the previous change (closures cannot be invoked through a `&`
pointer). This commit alters the `fn idx` method on the RandomAccessIterator
to take `&mut self` rather than `&self`.

[breaking-change]
std: Change CharEq to take `&mut self`

This is similar to the previous commits to allow invocation of a closure through
a `&mut self` pointer because `&self` is disallowed. One of the primary
implementors of the CharEq trait is a closure type, which would not work if the
method continued to have `&self`.

In addition to changing mutability of the `matches` method, this modifies the
following methods from &CharEq to take a type which implements CharEq by value.

* trim_chars
* trim_left_chars
* trim_right_chars

Where these methods were previously invoked via

    s.trim_chars(&'a')

it would now be invoked through

    s.trim_chars('a')

[breaking-change]
std: Change Finally to take `&mut self`

As with the previous commits, the Finally trait is primarily implemented for
closures, so the trait was modified from `&self` to `&mut self`. This will
require that any closure variable invoked with `finally` to be stored in a
mutable slot.

[breaking-change]
Fix other bugs with new closure borrowing

This fixes various issues throughout the standard distribution and tests.