rollup merge of #23949: aturon/stab-timeout

This commit renames and stabilizes:

* `Condvar::wait_timeout_ms` (renamed from `wait_timeout`)
* `thread::park_timeout_ms` (renamed from `park_timeout`)
* `thread::sleep_ms` (renamed from `sleep`)

In each case, the timeout is taken as a `u32` number of milliseconds,
rather than a `Duration`.

These functions are likely to be deprecated once a stable form of
`Duration` is available, but there is little cost to having these named
variants around, and it's crucial functionality for 1.0.

[breaking-change]

r? @alexcrichton

cc @sfackler @carllerche

rollup merge of #23948: nikomatsakis/feature-gate-rust-abi

Like it says.

r? @alexcrichton

Stabilize basic timeout functionality

This commit renames and stabilizes:

* `Condvar::wait_timeout_ms` (renamed from `wait_timeout`)
* `thread::park_timeout_ms` (renamed from `park_timeout`)
* `thread::sleep_ms` (renamed from `sleep`)

In each case, the timeout is taken as a `u32` number of milliseconds,
rather than a `Duration`.

These functions are likely to be deprecated once a stable form of
`Duration` is available, but there is little cost to having these named
variants around, and it's crucial functionality for 1.0.

[breaking-change]

rollup merge of #23939: nikomatsakis/fn-box

Conflicts:
src/liballoc/boxed.rs

rollup merge of #23951: alexcrichton/splitn

This commit is an implementation of [RFC 979][rfc] which changes the meaning of
the count parameter to the `splitn` function on strings and slices. The
parameter now means the number of items that are returned from the iterator, not
the number of splits that are made.

[rfc]: https://github.com/rust-lang/rfcs/pull/979

Closes #23911
[breaking-change]

std: Changing the meaning of the count to splitn

This commit is an implementation of [RFC 979][rfc] which changes the meaning of
the count parameter to the `splitn` function on strings and slices. The
parameter now means the number of items that are returned from the iterator, not
the number of splits that are made.

[rfc]: https://github.com/rust-lang/rfcs/pull/979

Closes #23911
[breaking-change]

rollup merge of #23947: aturon/revise-num

Recent numerics stabilization removed the inherent `min_value` and
`max_value` methods from integer types, assuming that the module-level
constants would suffice. However, that failed to account for the use
case in FFI code when dealing with integer type aliases.

This commit reintroduces the methods as `#[stable]`, since this is
essential functionality for 1.0.

It's unfortunate to freeze these as methods, but when we can provide
inherent associated constants these methods can be deprecated.

r? @sfackler
cc @alexcrichton

rollup merge of #23944: alexcrichton/rustup-beta

Switches rustup to using the beta channel by default. Includes #23824 for the implementation.

cc #20453
Closes #21149

rollup merge of #23942: vhbit/ios-rand

rollup merge of #23933: kgv/kgv_fix

Fix example and some text for: `read_line` takes `&mut String` and return `Result` instead `IoResult`.

r? @steveklabnik

rollup merge of #23867: nikomatsakis/issue-23086-take-3

This PR implements rust-lang/rfcs#1023. In the process it fixes #23086 and #23516. A few impls in libcore had to be updated, but the impact is generally pretty minimal. Most of the fallout is in the tests that probed the limits of today's coherence.

I tested and we were able to build the most popular crates along with iron (modulo errors around errors being sendable).

Fixes #23918.

rollup merge of #23568: steveklabnik/closure_docs

[rendered](https://github.com/steveklabnik/rust/blob/closure_docs/src/doc/trpl/closures.md)

r? @nikomatsakis

Path rustdoc test

rustup: Fix typo in nightly

Remove TODO

Feature gate rust-call ABI.

Re-add min_value, max_value methods

Recent numerics stabilization removed the inherent `min_value` and
`max_value` methods from integer types, assuming that the module-level
constants would suffice. However, that failed to account for the use
case in FFI code when dealing with integer type aliases.

This commit reintroduces the methods as `#[stable]`, since this is
essential functionality for 1.0.

It's unfortunate to freeze these as methods, but when we can provide
inherent associated constants these methods can be deprecated.

Collect the definition of the `Error` trait into `libstd` for now.  This
sidesteps a coherence difficulty where `liballoc` had to prove that
`&str: !Error`, which didn't involve any local types.

Re-write closures chapter

Rollup merge of #23932 - steveklabnik:doc_std_path, r=flaper87

Rollup merge of #23927 - frewsxcv:patch-7, r=Manishearth

Rollup merge of #23925 - steveklabnik:gh22914, r=Gankro

Fixes #22914

Said issue was mostly fixed, as there wasn't any examples when it was initially posted. This is mostly just some re-wording of some things and some cleanup

Rollup merge of #23924 - nrc:unqual-assoc3, r=alexcrichton

Basically stuff I did for unqualified assoc types which is worth landing by itself.

Rollup merge of #23895 - nikomatsakis:fn-trait-inheritance-add-impls, r=pnkfelix

The primary purpose of this PR is to add blanket impls for the `Fn` traits of the following (simplified) form:

    impl<F:Fn> Fn for &F
    impl<F:FnMut> FnMut for &mut F

However, this wound up requiring two changes:

1. A slight hack so that `x()` where `x: &mut F` is translated to `FnMut::call_mut(&mut *x, ())` vs `FnMut::call_mut(&mut x, ())`. This is achieved by just autoderef'ing one time when calling something whose type is `&F` or `&mut F`.
2. Making the infinite recursion test in trait matching a bit more tailored. This involves adding a notion of "matching" types that looks to see if types are potentially unifiable (it's an approximation).

The PR also includes various small refactorings to the inference code that are aimed at moving the unification and other code into a library (I've got that particular change in a branch, these changes just lead the way there by removing unnecessary dependencies between the compiler and the more general unification code).

Note that per rust-lang/rfcs#1023, adding impls like these would be a breaking change in the future.

cc @japaric
cc @alexcrichton
cc @aturon

Fixes #23015.

Rollup merge of #23867 - nikomatsakis:issue-23086-take-3, r=pnkfelix

This PR implements rust-lang/rfcs#1023. In the process it fixes #23086 and #23516. A few impls in libcore had to be updated, but the impact is generally pretty minimal. Most of the fallout is in the tests that probed the limits of today's coherence.

I tested and we were able to build the most popular crates along with iron (modulo errors around errors being sendable).

Fixes #23918.

Rollup merge of #23847 - bcoopers:read_clarification, r=sfackler

This introduces no functional changes except for reducing a few unnecessary operations and variables.  Vec has the behavior that, if you request space past the capacity with reserve(), it will round up to the nearest power of 2.  What that effectively means is that after the first call to reserve(16), we are doubling our capacity every time.  So using the DEFAULT_BUF_SIZE and doubling cap_size() here is meaningless and has no effect on the call to reserve().

Note that with #23842 implemented this will hopefully have a clearer API and less of a need for commenting.  If #23842 is not implemented then the most clear implementation would be to call reserve_exact(buf.capacity()) at every step (and making sure that buf.capacity() is not zero at the beginning of the function of course).

Edit- functional change now introduced.  We will now zero 16 bytes of the vector first, then double to 32, then 64, etc. until we read 64kB.  This stops us from zeroing the entire vector when we double it, some of which may be wasted work.  Reallocation still follows the doubling strategy, but the responsibility has been moved to vec.extend(), which calls reserve() and push_back().

Rollup merge of #23844 - kvark:try_unique, r=alexcrichton

While trying to implement parallel ECS processing, I stumbled upon the need to mutate `Arc` contents. The only existed method that allowed that was `make_unique`, but it has issues:
  - it may clone the data as if nothing happened, where the program may just need to crash
  - it forces `Clone` bound, which I don't have

The new `try_unique` allows accessing the contents mutably without `Clone` bound and error out if the pointer is not unique.

Rollup merge of #23066 - michaelwoerister:unreachable-if, r=pnkfelix

This PR solves #21559 by making sure that unreachable if-expressions are not further translated.

Could someone who knows their way around `trans` take a look at the changes in `controlflow.rs`? I'm not sure if any other code relies on any side-effects of translating unreachable things.

cc @nikomatsakis @nrc @eddyb

Remove `Thunk` struct and `Invoke` trait; change `Thunk` to be an alias
for `Box<FnBox()>`. I found the alias was still handy because it is
shorter than the fully written type.

This is a [breaking-change]: convert code using `Invoke` to use `FnBox`,
which is usually pretty straight-forward. Code using thunk mostly works
if you change `Thunk::new => Box::new` and `foo.invoke(arg)` to
`foo(arg)`.

Add (unstable) FnBox trait as a nicer replacement for `Thunk`. The doc
comment includes a test that also shows how it can be used.

rustup: Default to the beta channel

Switches rustup to using the beta channel by default

iOS: os::last_os_error() fallout

Merge branch 'fix-rustup' of https://github.com/richo/rust

Fallout in libsyntax/librustc: use newtype'd options for linked lists,
since `Option` is not fundamental and hence the old impls run afoul of
the orphan rules.

Fallout in libstd: remove impls now considered to conflict.

Update tests for new coherence rules, and add a swatch of new tests
probing the specifics of `Fundamental`.

Fixes #23086.
Fixes #23516.

Add `#[fundamental]` annotations into libcore so that `Sized` and the
`Fn` traits are considered fundamental, along with `Box` (though that is
mostly for show; the real type is `~T` in the compiler).

Implement the changes to coherence such that we consider a type to be
local only if matches `FUNDAMENTAL(LocalType)`, where `FUNDAMENTAL`
includes `&T` and types marked as fundamental (which includes `Box`).
Also apply these tests to negative reasoning.

Simplify `match` branches in iter.rs example

Auto merge of #23109 - nikomatsakis:closure-region-hierarchy, r=pnkfelix

Adjust internal treatment of the region hierarchy around closures. Work towards #3696.

r? @pnkfelix

Update comments

Remove the `Option<>` since when computing LUB since I believe that the
case where `None` was returned should never happen in practice; it
amounts to comparing regions from two unrelated hierarchies. (I was also
not able to make it happen.)

Implement the new region hierarchy rules, in which regions from distinct
hierarchies are judged based on the lexical relationship of their
respective fn bodies.

Add a meta-hierarchy of trees -- in future, each fn body will inhabit
its own disjoint region tree, and the new table encodes the lexical
relationships between those trees.

Auto merge of #23936 - pnkfelix:rollup, r=pnkfelix

This is an attempt to fix #23922

Update android tests to reflect API switch from `os::env` to `env::vars`.

Test fixes and rebase conflicts

Fix rust book error-handling.md for new std::io.

Fix example and some text for: `read_line` takes `&mut String` and return `Result` instead `IoResult`.

Add examples + documentation for std::path

Added Arc::try_unique

Tidying up and reformatting

rollup merge of #23923: steveklabnik/gh23688

Fixes #23688

r? @alexcrichton

rollup merge of #23921: aturon/issue-17746

Closes #17746

rollup merge of #23863: pnkfelix/arith-oflo-const-eval

const_eval : add overflow-checking for {`+`, `-`, `*`, `/`, `<<`, `>>`}.

One tricky detail here: There is some duplication of labor between `rustc::middle::const_eval` and `rustc_trans::trans::consts`. It might be good to explore ways to try to factor out the common structure to the two passes (by abstracting over the particular value-representation used in the compile-time interpreter).

----

Update: Rebased atop #23841

Fix #22531

Fix #23030

Fix #23221

Fix #23235

dealing with fallout to the tests, in particular diffs between 32- vs 64-bit targets.

See also #23926.

Unify handling of checking repeat-count validity.

Fixes to compile-fail error messages post-rebase.

Include feature `core` to get access to `wrapping_add`.

Test cases for checking arithmetic overflow during const eval.

Fallout from changes for overflow-checking during constant evaluation.

rustc_trans::trans::consts add overflow checking

rustc::middle::const_eval : add overflow-checking for {+, -, *}.

The overflow-checking attempts to accommodate early evaluation where
we do not have type information yet.

Also, add fixme note about something that has been bothering me.

rust_llvm: Add way to reflectively ask if a ValueRef is a known constant int.

Add option-returning variants to `const_to_int`/`const_to_uint` that
never assert fail. (These will be used for overflow checking from
rustc_trans::trans::consts.)

ty.rs improve error feedback when const-eval errs during repeat count eval.

Refactored ty::ctxt so node_types mutations must go through ty methods.

Added overflowing_{div,rem,shl,shr} method implementations to WrappingOps.

Fix #23890: const-eval `_ as usize`, `_ as isize` must dispatch to target type.

fix post rebase.

Added tests for discriminant overflows.

Added type-specific overflow checks when computing enum discriminant values.

Moved such overflow checking into one place (in `rustc::middle::ty`,
since it needs to be run on-demand during `const_eval` in some
scenarios), and revised `rustc_typeck` accordingly.

(Note that we only check for overflow if program did not provide a
discriminant value explicitly.)

Fix #23030

Fix #23221

Fix #23235

Test fixes and rebase conflicts, round 3

Improvements to PhantomData<T>'s docs 👻

Fixes #22914

Add description of + for multiple trait bounds

Fixes #23688

Pretty print ids for assoc items

Add test for #17746

Closes #17746

rollup merge of #23919: alexcrichton/stabilize-io-error

Conflicts:
src/libstd/fs/tempdir.rs
src/libstd/io/error.rs

rollup merge of #23899: steveklabnik/gh23851

Conflicts:
src/libcore/iter.rs

std: Stabilize last bits of io::Error

This commit stabilizes a few remaining bits of the `io::Error` type:

* The `Error::new` method is now stable. The last `detail` parameter was removed
  and the second `desc` parameter was generalized to `E: Into<Box<Error>>` to
  allow creating an I/O error from any form of error. Currently there is no form
  of downcasting, but this will be added in time.

* An implementation of `From<&str> for Box<Error>` was added to liballoc to
  allow construction of errors from raw strings.

* The `Error::raw_os_error` method was stabilized as-is.

* Trait impls for `Clone`, `Eq`, and `PartialEq` were removed from `Error` as it
  is not possible to use them with trait objects.

This is a breaking change due to the modification of the `new` method as well as
the removal of the trait implementations for the `Error` type.

[breaking-change]

rollup merge of #23920: steveklabnik/gh23881

Fixes #23881

rollup merge of #23901: steveklabnik/fix_links_str

Remove broken links that should just point to the current page, and while we're at it, re-wrap to 100 chars.

Move benchmark tests to unstable section

Fixes #23881

rollup merge of #23288: alexcrichton/issue-19470

This is a deprecated attribute that is slated for removal, and it also affects
all implementors of the trait. This commit removes the attribute and fixes up
implementors accordingly. The primary implementation which was lost was the
ability to compare `&[T]` and `Vec<T>` (in that order).

This change also modifies the `assert_eq!` macro to not consider both directions
of equality, only the one given in the left/right forms to the macro. This
modification is motivated due to the fact that `&[T] == Vec<T>` no longer
compiles, causing hundreds of errors in unit tests in the standard library (and
likely throughout the community as well).

Closes #19470
[breaking-change]

rollup merge of #23908: aturon/stab-more-stragglers

* The `io::Seek` trait.
* The `Iterator::{partition, unsip}` methods.
* The `Vec::into_boxed_slice` method.
* The `LinkedList::append` method.
* The `{or_insert, or_insert_with` methods in the `Entry` APIs.

r? @alexcrichton

rollup merge of #23907: alexcrichton/impl-exit

This commit is an implementation of [RFC #1011][rfc] which adds an `exit`
function to the standard library for immediately terminating the current process
with a specified exit code.

[rfc]: https://github.com/rust-lang/rfcs/pull/1011

Closes #23914

rollup merge of #23906: steveklabnik/spellin

rollup merge of #23902: freebroccolo/master

Test fixes and rebase conflicts, round 2

rollup merge of #23873: alexcrichton/remove-deprecated

Conflicts:
src/libcollectionstest/fmt.rs
src/libcollectionstest/lib.rs
src/libcollectionstest/str.rs
src/libcore/error.rs
src/libstd/fs.rs
src/libstd/io/cursor.rs
src/libstd/os.rs
src/libstd/process.rs
src/libtest/lib.rs
src/test/run-pass-fulldeps/compiler-calls.rs

rollup merge of #23879: seanmonstar/del-from-error

Conflicts:
src/libcore/error.rs

rollup merge of #23875: aturon/revise-convert-2

* Marks `#[stable]` the contents of the `std::convert` module.

* Added methods `PathBuf::as_path`, `OsString::as_os_str`,
  `String::as_str`, `Vec::{as_slice, as_mut_slice}`.

* Deprecates `OsStr::from_str` in favor of a new, stable, and more
  general `OsStr::new`.

* Adds unstable methods `OsString::from_bytes` and `OsStr::{to_bytes,
  to_cstring}` for ergonomic FFI usage.

[breaking-change]

r? @alexcrichton

Test fixes and rebase conflicts, round 1

rollup merge of #23872: huonw/eager-lexing

Conflicts:
src/libsyntax/parse/lexer/mod.rs

std: Clean out #[deprecated] APIs

This commit cleans out a large amount of deprecated APIs from the standard
library and some of the facade crates as well, updating all users in the
compiler and in tests as it goes along.

rollup merge of #23893: frewsxcv/patch-6

rollup merge of #23886: demelev/remove_as_slice_usage

rollup merge of #23885: steveklabnik/doc_std_env

Just one or two things to finish this module off

rollup merge of #23882: wettowelreactor/patch-2

Removed duplicate words

rollup merge of #23878: Ryman/stable_extremes

`min`-like functions now return the leftmost element/input for equal elements.
`max`-like return the rightmost.

Closes #23687.

cc @HeroesGrave, @aturon, @alexcrichton

rollup merge of #23876: alexcrichton/stabilize-any

This commit stabilizes the following APIs:

* `TypeId::of` - now that it has an `Any` bound it's ready to be stable.
* `Box<Any>::downcast` - now that an inherent impl on `Box<Any>` as well as
  `Box<Any+Send>` is allowed the `BoxAny` trait is removed in favor of these
  inherent methods.

This is a breaking change due to the removal of the `BoxAny` trait, but
consumers can simply remove imports to fix crates.

[breaking-change]

rollup merge of #23766: alexcrichton/stabilize-raw-fd

This commit stabilizes the platform-specific `io` modules, specifically around
the traits having to do with the raw representation of each object on each
platform.

Specifically, the following material was stabilized:

* `AsRaw{Fd,Socket,Handle}`
* `RawFd` (renamed from `Fd`)
* `RawHandle` (renamed from `Handle`)
* `RawSocket` (renamed from `Socket`)
* `AsRaw{Fd,Socket,Handle}` implementations
* `std::os::{unix, windows}::io`

The following material was added as `#[unstable]`:

* `FromRaw{Fd,Socket,Handle}`
* Implementations for various primitives

There are a number of future improvements that are possible to make to this
module, but this should cover a good bit of functionality desired from these
modules for now. Some specific future additions may include:

* `IntoRawXXX` traits to consume the raw representation and cancel the
  auto-destructor.
* `Fd`, `Socket`, and `Handle` abstractions that behave like Rust objects and
  have nice methods for various syscalls.

At this time though, these are considered backwards-compatible extensions and
will not be stabilized at this time.

This commit is a breaking change due to the addition of `Raw` in from of the
type aliases in each of the platform-specific modules.

[breaking-change]