Regression test for #15034

Closes #15034.

Regression test for #14227

Closes #14227.

Regression test for #14386

Closes #14386.

Regression tests for #13853

Closes #13853, #14889.

Regression test for #13808

Closes #13808.

Regression test for #13665

Closes #13665.

Regression test for #13655

Closes #13655.

Regression test for simple case of #9197

Regression test for #8874

Closes #8874.

Update test for #5543

Closes #5543.

Regression test for #3902

Closes #3902.

auto merge of #20136 : eddyb/rust/format-args, r=alexcrichton

We have the technology: no longer do you need to write closures to use `format_args!`.
This is a `[breaking-change]`, as it forces you to clean up old hacks - if you had code like this:
```rust
format_args!(fmt::format, "{} {} {}", a, b, c)
format_args!(|args| { w.write_fmt(args) }, "{} {} {}", x, y, z)
```
change it to this:
```rust
fmt::format(format_args!("{} {} {}", a, b, c))
w.write_fmt(format_args!("{} {} {}", x, y, z))
```
To allow them to be called with `format_args!(...)` directly, several functions were modified to
take `fmt::Arguments` by value instead of by reference. Also, `fmt::Arguments` derives `Copy`
now in order to preserve all usecases that were previously possible.

Fallout of changing format_args!(f, args) to f(format_args!(args)).

syntax: change format_args! to produce fmt::Arguments instead of calling a function with them.

syntax: use std::string::String unqualified in format.

syntax: turn the match-call generated by format_args inside-out.

syntax: format: put static arrays in their own blocks to avoid needing a wrapper block.

syntax: format: remove unused method_statics field.

auto merge of #19916 : SimonSapin/rust/ascii-reform, r=sfackler

Implements [RFC 486](https://github.com/rust-lang/rfcs/pull/486). Fixes #19908.

* Rename `to_ascii_{lower,upper}` to `to_ascii_{lower,upper}case`, per #14401
* Remove the `Ascii` type and associated traits: `AsciiCast`, `OwnedAsciiCast`, `AsciiStr`, `IntoBytes`, and `IntoString`.
* As a replacement, add `.is_ascii()` to `AsciiExt`, and implement `AsciiExt` for `u8` and `char`.

[breaking-change]

auto merge of #20244 : japaric/rust/bc-no-move, r=nikomatsakis

closes #19141
closes #20193
closes #20228

---

Currently whenever we encounter `let f = || {/* */}`, we *always* type check the RHS as a *boxed* closure. This is wrong when the RHS is `move || {/* */}` (because boxed closures can't capture by value) and generates all sort of badness during trans (see issues above). What we *should* do is always type check `move || {/* */}` as an *unboxed* closure, but ~~I *think* (haven't tried)~~ (2) this is not feasible right now because we have a limited form of kind (`Fn` vs `FnMut` vs `FnOnce`) inference that only works when there is an expected type (1).

In this PR, I've chosen to generate a type error whenever `let f = move || {/* */}` is encountered. The error asks the user to annotate the kind of the unboxed closure (e.g. `move |:| {/* */}`). Once annotated, the compiler will type check the RHS as an unboxed closure which is what the user wants.

r? @nikomatsakis

(1) AIUI it only triggers in this scenario:

``` rust
fn is_uc<F>(_: F) where F: FnOnce() {}

fn main() {
    is_uc(|| {});  // type checked as unboxed closure with kind `FnOnce`
}
```

(2) I checked, and it's not possible because `check_unboxed_closure` expects a `kind` argument, but we can't supply that argument in this case (i.e. `let f = || {}`, what's the kind?). We could force the `FnOnce` kind in that case, but that's ad hoc. We should try to infer the kind depending on how the closure is used afterwards, but there is no inference mechanism to do that (at least, not right now).

auto merge of #20119 : FlaPer87/rust/oibit-send-and-friends, r=nikomatsakis

More work on opt-in built in traits. `Send` and `Sync` are not opt-in, `OwnedPtr` renamed to `UniquePtr` and the `Send` and `Sync` traits are now unsafe.

NOTE: This likely needs to be rebased on top of the yet-to-land snapshot.

r? @nikomatsakis

cc #13231

Make trait's impls consistent for unix/windows

Implement Sync/Send for windows' UnixStream

auto merge of #20238 : barosl/rust/regex-repeater-panic, r=huonw

This bug has also affected the `regex!` macro, which has caused an ICE when such an invalid expression is provided.

Fixes #20208.

auto merge of #20158 : nikomatsakis/rust/fn-inference-refactor, r=eddyb

Various refactorings simplifying the mem-categorization and regionck interface. This is working towards an improvement for closure-and-upvar-mode inference.

r? @eddyb

auto merge of #20143 : csouth3/rust/vecmap-reserve, r=Gankro

Implement `reserve_len` and `reserve_len_exact` for `VecMap` in accordance with rust-lang/rfcs#509.

auto merge of #19254 : nick29581/rust/dxr-glob, r=pcwalton

There is also some work here to make resolve a bit more stable - it no longer overwrites a specific import with a glob import.

r?

Rebasing changes

Implement Sync/Send for windows TCP types

auto merge of #20133 : apasel422/rust/binary_heap, r=alexcrichton

Some more tidying up.

Fix fallout

save-analysis: emit names of items that a glob import actually imports.

There is also some work here to make resolve a bit more stable - it no longer overwrites a specific import with a glob import.

[breaking-change]

Import shadowing of single/list imports by globs is now forbidden. An interesting case is where a glob import imports a re-export (`pub use`) of a single import. This still counts as a single import for the purposes of shadowing .You can usually fix any bustage by re-ordering such imports. A single import may still shadow (override) a glob import or the prelude.

Implement RaceBox for StdinReader

Add a Racy type to bench tests

Implement Sync/Send for ArcInner and Weak

Impl Sync/Send for Rawlink

Make Barrier and Condvar Sync/Send

Keep track of the whole error chain

Relax `Arc` bounds don't require Sync+Send

Besides the above making sense, it'll also allow us to make `RacyCell`
private and use UnsafeCell instead.

Rename `UniquePtr` to `Unique`

Mostly following the convention in RFC 356

Implement `Sync` for some windows sys types

Move RacyCell to `std::comm`

RacyCell is not exactly what we'd like as a final implementation for
this. Therefore, we're moving it under `std::comm` and also making it
private.

Make Send and Sync traits unsafe

Rename `OwnedPtr` to `UniquePtr`

Require types to opt-in Sync

typeck: boxed closures can't capture by value

closes #19141
closes #20193
closes #20228

auto merge of #20218 : alexcrichton/rust/jemalloc-sections, r=luqmana

It's quite possible that small programs don't use all of jemalloc, and building
with -ffunction-sections and -fdata-sections allows the linker (via
--gc-sections) to strip out all unused code at link time. This decreases the
size of a "hello world" executable for me from 716K to 482K with no measurable
impact on link time. After this patch jemalloc is still the largest portion of
our hello world executables, but this helps cut down on the size at least
somewhat!

Prevent Regex::new() from panicking when a non-AST item is repeated

This bug has also affected the regex! macro, which has caused an ICE
when such an invalid expression is provided.

Fixes #20208.

auto merge of #20183 : japaric/rust/doctests, r=alexcrichton

#20075 introduced a bug where unmarked code fences weren't considered as doctests. This PR fixes the logic.

---

This passed `check-stage1-rustdoc`, and I manually checked that:

``` rust
//! ```
//! println!("Hello")
//! ```
//!
//! ``` rust
//! println!("Hello")
//! ```
//!
//! ``` sh
//! println!("Hello")
//! ```
//!
//! ``` ignore
//! println!("Hello")
//! ```
```

Generated:

``` rust
running 3 tests
test _2 ... ignored
test _0 ... ok
test _1 ... ok
```

I'd love to add that as a test, but I have no idea how to do that with our testing infrastructure. If anyone knows how, do let me know!

r? @alexcrichton
@seanmonstar feedback?

Fix up remaining usage of `to_ascii`.

auto merge of #20180 : jroesch/rust/clean-where-predicate, r=alexcrichton

Add support for all variants of ast::WherePredicate in clean/mod.rs. Fixes #20048, but will need modification when EqualityPredicates are fully implemented in #20041.

Fix up remaining usage of `to_ascii`.

auto merge of #20167 : michaelwoerister/rust/for-loop-var, r=alexcrichton

... really this time `:)`

I went for the simpler fix after all since it turned out to become a bit too complicated to extract the current iteration value from its containing `Option` with the different memory layouts it can have. It's also what we already do for match bindings.

I also extended the new test case to include the "simple identifier" case.

Fixes #20127, fixes #19732

Move mem-categorization more things to use TYPER for the method origin

Remove `McResult` from the mem-categorization interface.

Extend Typer interface to include `expr_ty_adjusted` so that we can
remove another direct dependency on tcx from euv.

Remove the regionck impl of Typer and just use fcx. This requires
modifying fcx to remove type variables where possible, but that's it.

Use the typer in ExprUseVisitor and do not hard code to tcx

std::ascii: Use u8 methods rather than the maps directly.

Remove Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, IntoBytes, IntoString.

As a replacement, add is_ascii() to AsciiExt, and implement AsciiExt for u8 and char.

[breaking-change]

auto merge of #20024 : mneumann/rust/dragonfly-fixes3, r=alexcrichton

mk: Build jemalloc with -ffunction-sections

It's quite possible that small programs don't use all of jemalloc, and building
with -ffunction-sections and -fdata-sections allows the linker (via
--gc-sections) to strip out all unused code at link time. This decreases the
size of a "hello world" executable for me from 716K to 482K with no measurable
impact on link time. After this patch jemalloc is still the largest portion of
our hello world executables, but this helps cut down on the size at least
somewhat!

auto merge of #19934 : tomjakubowski/rust/rustdoc-unboxed-closures-redux, r=alexcrichton

We render HRTB and the unboxed closure trait sugar (the so-called
"parenthesized" notation) where appropriate. Also address the new
`for` syntax on the old closures.

auto merge of #20117 : lfairy/rust/rename-include-bin, r=alexcrichton

According to [RFC 344][], methods that return `&[u8]` should have names ending in `bytes`. Though `include_bin!` is a macro not a method, it seems reasonable to follow the convention anyway.

We keep the old name around for now, but trigger a deprecation warning when it is used.

[RFC 344]: https://github.com/rust-lang/rfcs/blob/master/text/0344-conventions-galore.md

[breaking-change]

auto merge of #19813 : barosl/rust/autoderef-type-inference-ice, r=pnkfelix

`check::autoderef()` returns a `ty_err` when it fails to infer the type. `probe::probe()` should respect this failure and fail together to prevent further corruption.

Fixes #19692.
Fixes #19583.
Fixes #19297.

Rename to_ascii_{lower,upper} to to_ascii_{lower,upper}case, per #14401

[breaking-change]

rustdoc: Use Fn trait sugar for external paths

Fix #19909

rustdoc: Use unboxed closure sugar

This unfortunately leaves sugaring Fn/FnMut/FnOnce on cross-crate
re-exports for future work.

cc #19909

rustdoc: render higher-rank trait bounds

Fix #19915

rustdoc: render `for<>` on old closure lifetimes

auto merge of #20060 : Aatch/rust/enum-repr, r=alexcrichton

The previous behaviour of using the smallest type possible caused LLVM
to treat padding too conservatively, causing poor codegen. This commit
changes the behaviour to use an alignment-sized integer as the
discriminant. This keeps types the same size, but helps LLVM understand
the data structure a little better, resulting in better codegen.

clean up `BinaryHeap` code

Address code review nits

auto merge of #19858 : nick29581/rust/ranges, r=aturon

Closes #19794

r? @aturon for the first patch
r? @nikomatsakis for the rest

rustdoc: unmarked code fences are doctests too

auto merge of #19758 : tbu-/rust/pr_fp_name, r=alexcrichton

This is a [breaking-change].

Support all variants of WherePredicate

Adds support for all variants of ast::WherePredicate in clean/mod.rs. Fixes #20048, but will need modification when EqualityPredicates are fully implemented in #20041.

Review changes

Tests

Type checking and trans for ranges

Add syntax for ranges

Add lang items for ranges.

Add structs for ranges to core::ops.

auto merge of #20083 : eddyb/rust/fix-expectation, r=nikomatsakis

This fixes a few corner cases with expected type propagation, e.g.:
```rust
fn take_int_slice(_: &[int]) {}
take_int_slice(&if 1 < 0 { [ 0, 1 ] } else { [ 0, 1 ] });
```
```rust
<anon>:2:28: 2:36 error: mismatched types: expected `[int]`, found `[int, ..2]`
<anon>:2 take_int_slice(&if 1 < 0 { [ 0, 1 ] } else { [ 0, 1 ] });
                                    ^~~~~~~~
<anon>:2:46: 2:54 error: mismatched types: expected `[int]`, found `[int, ..2]`
<anon>:2 take_int_slice(&if 1 < 0 { [ 0, 1 ] } else { [ 0, 1 ] });
                                                      ^~~~~~~~
```
Right now we unpack the expected `&[int]` and pass down `[int]`, forcing
rvalue expressions to take unsized types, which causes mismatch errors.
Instead, I replaced that expectation with a weaker hint, for the unsized
cases - a hint is still required to infer the integer literals' types, above.

Fixes #20169.

Rename and namespace `FPCategory`

Rename `FPCategory` to `FpCategory` and `Fp* to `*` in order to adhere to the
naming convention

This is a [breaking-change].

Existing code like this:
```
use std::num::{FPCategory, FPNaN};
```
should be adjusted to this:
```
use std::num::FpCategory as Fp
```

In the following code you can use the constants `Fp::Nan`, `Fp::Normal`, etc.

rustc_typeck: don't expect rvalues to have unsized types.

debuginfo: Add test case for destructured for-loop variable.

debuginfo: Clean the debuginfo module up a bit.

debuginfo: Create debuginfo for for-loop variables again.

Merge pull request #20155 from tbu-/pr_vecmap_fiximpls

Fix `collections::VecMap`'s `PartialEq` implementation

Reviewed-by: Gankro

Merge pull request #20153 from brianloveswords/patch-1

Update complement-bugreport.md

Reviewed-by: alexcrichton

Merge pull request #20001 from huonw/speeling2

Fix some spelling errors.

Reviewed-by: nick29581

Merge pull request #19886 from brson/rustup

rustup: Don't do verbose tarball extraction

Reviewed-by: alexcrichton

Rename include_bin! to include_bytes!

According to [RFC 344][], methods that return `&[u8]` should have names
ending in `bytes`. Though `include_bin!` is a macro not a method, it
seems reasonable to follow the convention anyway.

We keep the old name around for now, but trigger a deprecation warning
when it is used.

[RFC 344]: https://github.com/rust-lang/rfcs/blob/master/text/0344-conventions-galore.md

[breaking-change]

Make alignment-forcing case work the same on 64 and 32-bit platforms

Fix some spelling errors.

auto merge of #20145 : alexcrichton/rust/rollup, r=alexcrichton

Fix `collections::VecMap`'s `PartialEq` implementation

Previously it took capacity into account.

Additionally remove the `ne` implementation of `RingBuf` which is the default
one anyway.

Update complement-bugreport.md

`--version=verbose` doesn't exist anymore, `--version --verbose` is the way to do that now.

Add enum size cases to type-sizes test