libstd: add a dummy field to `OsRng` to avoid out of module construction

Remove internal uses of `marker::NoCopy`

auto merge of #19785 : brson/rust/rollup, r=brson

rollup merge of #19814: jbranchaud/fix-a-typo-in-ownership-guide

rollup merge of #19812: frewsxcv/expansion-include-enum

In preparation for [removing the `std::cmp::Ordering` reexport](https://github.com/rust-lang/rust/issues/19253), this needs to be done to prevent errors like:

```
note: in expansion of #[deriving]
note: expansion site
error: unresolved name `std::cmp::Equal`
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
                                             ^~~
```

rollup merge of #19804: kballard/vim-new-unicode-escapes

rollup merge of #19802: jbranchaud/add-btreeset-new-doctest

rollup merge of #19793: tomjakubowski/metadata-const-attrs

Fix #19773

Together with #19774 (which this is rebased on):

Fix #18156, fix #19722, fix #19185

r? @alexcrichton (since this was your suggestion!)

rollup merge of #19787: akiss77/fix-i8-c_char

On AArch64, libc::c_char is u8. There are some places in the code where i8 is assumed, which causes compilation errors.

(AArch64 is not officially supported yet, but this change does not hurt any other targets and makes the code future-proof.)

rollup merge of #19784: csouth3/vim-syntax-iter

Vim still incorrectly highlights just `ExactSize` as a valid trait name, but the trait has been renamed to `ExactSizeIterator`.

rollup merge of #19779: Noctune/master

The old PartialOrd impl for raw pointers would always return Some(_), so It might as well implement Ord too.

rollup merge of #19775: SimonSapin/gedit-new-unicode-escape

rollup merge of #19774: tomjakubowski/rustdoc-consts-statics

Build `clean::ConstantItem` values in the `inline` module and
pretty-print the AST for inlined const items.

Doc strings are still missing from inlined constants (see #19773).

Partially address #18156, #19722, #19185

Fix #15821

r? @alexcrichton

rollup merge of #19771: jbranchaud/add-btreeset-iter-doctests

rollup merge of #19763: csouth3/remove-featuregates

This is a revival of #19517 (per request of @alexcrichton) now that the new snapshots have landed.  We can now remove the last feature gates for if_let, while_let, and tuple_indexing scattered throughout the test sources since these features have been added to Rust.

Closes #19473.

rollup merge of #19754: steveklabnik/remove_sundown

rollup merge of #19746: steveklabnik/gh9266

Fixes #9266

rollup merge of #19738: steveklabnik/gh19717

Fixes #19717

rollup merge of #19735: sethpollack/patch-1

rollup merge of #19714: steveklabnik/gh16219

These should be properly annotated instead.

Fixes #16219.

rollup merge of #19710: steveklabnik/gh15449

Fixes #15499.

rollup merge of #19709: steveklabnik/po4a_fix

This line was declared twice, which causes the build of i10n docs to
fail.

auto merge of #19778 : aochagavia/rust/ice, r=alexcrichton

Fixes #19734

auto merge of #19750 : murarth/rust/rusti-support, r=brson

Makes a couple changes that support the implementation of a REPL:

* Implementation of wrapper code for LLVM ExecutionEngine API
* Fixing a change I made earlier to reset compiler state in `phase_1_[...]`
  instead of `compile_input` as the latter is not used in a REPL

auto merge of #19742 : vhbit/rust/copy-for-bitflags, r=alexcrichton

auto merge of #19703 : nikomatsakis/rust/unsafe-trait, r=acrichto

This PR allows declaring traits and impls as `unsafe`. An `unsafe` trait requires an `unsafe` impl. An `unsafe` impl does not permit unsafe code within its interior (unless that code is contained within an unsafe block or unsafe fn, as normal). The commits are standalone.

r? @alexcrichton
cc #13231

Add a bunch of new tests per Alex's suggestion.

Implement `unsafe trait` semantics.

Parse `unsafe impl` but don't do anything particularly interesting with the results.

Parse `unsafe trait` but do not do anything with it beyond parsing and integrating into rustdoc etc.

Rename FnStyle trait to Unsafety.

auto merge of #19725 : vadimcn/rust/inst-path, r=alexcrichton

Change default installation directory to %SYSTEMDRIVE%\Rust.
Modify user PATH, rather than system PATH.

auto merge of #19338 : nikomatsakis/rust/unboxed-closure-purge-the-proc, r=acrichto

They are replaced with unboxed closures.

cc @pcwalton @aturon

This is a [breaking-change]. Mostly, uses of `proc()` simply need to be converted to `move||` (unboxed closures), but in some cases the adaptations required are more complex (particularly for library authors). A detailed write-up can be found here: http://smallcultfollowing.com/babysteps/blog/2014/11/26/purging-proc/

The commits are ordered to emphasize the more important changes, but are not truly standalone.

auto merge of #19690 : barosl/rust/struct-variant-as-a-function-ice, r=alexcrichton

Unlike a tuple variant constructor which can be called as a function, a struct variant constructor is not a function, so cannot be called.

If the user tries to assign the constructor to a variable, an ICE occurs, because there is no way to use it later. So we should stop the constructor from being used like that.

A similar mechanism already exists for a normal struct, as it prohibits a struct from being resolved. This commit does the same for a struct variant.

This commit also includes some changes to the existing tests.

Fixes #19452.

Stop using diagnostics to avoid merge conflicts.

Temporarily remove issue #14039; it is fixed and re-added by PR #19438

Add some tests for obsolete code, sugar used in appropriate ways.

Update emacs and vi modes.

Update guide/intro to take into account the removal of `proc`.

cc @steveklabnick

Delete tests that are either no longer relevant or which have
duplicate tests around object types.

Mostly rote conversion of `proc()` to `move||` (and occasionally `Thunk::new`)

Rewrite WorkItem not to use `proc()`.

Patch rustdoc to include missing types, make the match exhaustive
to prevent such oversights in the future.

Remove `proc` types/expressions from the parser, compiler, and
language. Recommend `move||` instead.

Adjust feature gates to allow for parenthetical notation to be used
with the fn traits

Purge the hack that allows `FnOnce` to be used with a by-value self method.  Besides being yucky, it will cause problems if we try to make all traits implement themselves, which would make a lot of things in life easier. Also, it was inextricably linked to `Box`, which was not the intention.  We can work around its absence, so better to reimplement it later in a more thorough fashion.

Rewrite threading infrastructure, introducing `Thunk` to represent
boxed `FnOnce` closures.

auto merge of #19677 : japaric/rust/deprecate-tupleN, r=alexcrichton

r? @alexcrichton or anyone else
closes #18006

auto merge of #19669 : alfie/rust/master, r=sanxiyn

Get rid of all the remaining uses of `refN`/`valN`/`mutN`/`TupleN`

libcore: allow deprecated `valN` methods on doc tests

libgraphviz: use tuple indexing

libcoretest: use tuple indexing

librustdoc: use tuple indexing

librustc_trans: use tuple indexing

librustc: use tuple indexing

libsyntax: use tuple indexing

libregex: use tuple indexing

libstd: use tuple indexing

libcollections: use tuple indexing

libunicode: use tuple indexing

Deprecate the `TupleN` traits

auto merge of #19467 : japaric/rust/uc, r=alexcrichton

This PR moves almost all our current uses of closures, both in public API and internal uses, to the new "unboxed" closures system.

In most cases, downstream code that *only uses* closures will continue to work as it is. The reason is that the `|| {}` syntax can be inferred either as a boxed or an "unboxed" closure according to the context. For example the following code will continue to work:

``` rust
some_option.map(|x| x.transform_with(upvar))
```

And will get silently upgraded to an "unboxed" closure.

In some other cases, it may be necessary to "annotate" which `Fn*` trait the closure implements:

```
// Change this
|x| { /* body */}
// to either of these
|: x| { /* body */}  // closure implements the FnOnce trait
|&mut : x| { /* body */}  // FnMut
|&: x| { /* body */}  // Fn
```

This mainly occurs when the closure is assigned to a variable first, and then passed to a function/method.

``` rust
let closure = |: x| x.transform_with(upvar);
some.option.map(closure)
```

(It's very likely that in the future, an improved inference engine will make this annotation unnecessary)

Other cases that require annotation are closures that implement some trait via a blanket `impl`, for example:

- `std::finally::Finally`
- `regex::Replacer`
- `std::str::CharEq`

``` rust
string.trim_left_chars(|c: char| c.is_whitespace())
//~^ ERROR: the trait `Fn<(char,), bool>` is not implemented for the type `|char| -> bool`
string.trim_left_chars(|&: c: char| c.is_whitespace())  // OK
```

Finally, all implementations of traits that contain boxed closures in the arguments of their methods are now broken. And will need to be updated to use unboxed closures. These are the main affected traits:

- `serialize::Decoder`
- `serialize::DecoderHelpers`
- `serialize::Encoder`
- `serialize::EncoderHelpers`
- `rustrt::ToCStr`

For example, change this:

``` rust
// libserialize/json.rs
impl<'a> Encoder<io::IoError> for Encoder<'a> {
    fn emit_enum(&mut self,
                 _name: &str,
                 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
        f(self)
    }
}
```

to:

``` rust
// libserialize/json.rs
impl<'a> Encoder<io::IoError> for Encoder<'a> {
    fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
        F: FnOnce(&mut Encoder<'a>) -> EncodeResult
    {
        f(self)
    }
}
```

[breaking-change]

---

### How the `Fn*` bound has been selected

I've chosen the bounds to make the functions/structs as "generic as possible", i.e. to let them allow the maximum amount of input.

- An `F: FnOnce` bound accepts the three kinds of closures: `|:|`, `|&mut:|` and `|&:|`.
- An `F: FnMut` bound only accepts "non-consuming" closures: `|&mut:|` and `|&:|`.
- An `F: Fn` bound only accept the "immutable environment" closures: `|&:|`.

This means that whenever possible the `FnOnce` bound has been used, if the `FnOnce` bound couldn't be used, then the `FnMut` was used. The `Fn` bound was never used in the whole repository.

The `FnMut` bound was the most used, because it resembles the semantics of the current boxed closures: the closure can modify its environment, and the closure may be called several times.

The `FnOnce` bound allows new semantics: you can move out the upvars when the closure is called. This can be effectively paired with the `move || {}` syntax to transfer ownership from the environment to the closure caller.

In the case of trait methods, is hard to select the "right" bound since we can't control how the trait may be implemented by downstream users. In these cases, I have selected the bound based on how we use these traits in the repository. For this reason the selected bounds may not be ideal, and may require tweaking before stabilization.

r? @aturon

librustc_borrowck: add `#![feature(unboxed_closures)]`

libstd: add missing imports

Remove some unnecessary `move` keywords

libtest: use unboxed closures

librustc_driver: use unboxed closures

librustc_typeck: use unboxed closures

librustdoc: use unboxed closures

librustc_trans: use unboxed closures

librustc_trans: fix fallout

librustc_typeck: fix fallout

librustc: use unboxed closures

librustc_llvm: use unboxed closures

librustc_trans: fix fallout

librustc_back: use unboxed closures

librustc: fix fallout

libsyntax: use unboxed closures

Fix benches

libstd: use unboxed closures

librustrt: use unboxed closures

libregex_macros: use unboxed closures

libcollections: use unboxed closures

libserialize: use unboxed closures

libregex: use unboxed closures

libarena: use unboxed closures

libregex: fix fallout in doc tests

libregex: impl Replacer for FnMut(&Captures) -> String implementors

librustc: fix fallout

librbml: use unboxed closures in free functions

librbml: fix fallout

libserialize: use unboxed closures

librand: use unboxed closures in `distributions` module

libgraphviz: use unboxed closures in `LabelText` methods

libgetopts: use unboxed closures in `each_split_within`

libcore: use unboxed closures in `slice::raw` free functions

libcore: use unboxed closures in `float_to_str_bytes_common`

libcollections: use unboxed closures in `VecMap` methods

libgraphviz: fix fallout