Have worker-local GlobalArenas

Add a WorkerLocal abstraction

Update recursion limits

Ensure ImplicitCtxt is Sync

Fix optimization_fuel

Fix OneThread

Auto merge of #51181 - mbrubeck:prelude, r=petrochenkov

Add std/core to prelude if extern_prelude enabled

Fixes #50605

Auto merge of #51060 - michaelwoerister:thread-safe-consts, r=Zoxc

Make const decoding thread-safe.

This is an alternative to https://github.com/rust-lang/rust/pull/50957. It's a proof of concept (e.g. it doesn't adapt metadata decoding, just the incr. comp. cache) but I think it turned out nice. It's rather simple and does not require passing around a bunch of weird closures, like we currently do.

If you (@Zoxc & @oli-obk) think this approach is good then I'm happy to finish and clean this up.

Note: The current version just spins when it encounters an in-progress decoding. I don't have a strong preference for this approach. Decoding concurrently is equally fine by me (or maybe even better because it doesn't require poisoning).

r? @Zoxc

Remove outdated AllocId decoding function.

Make metadata decoding use AllocDecodingState/Session.

Make const decoding from the incremental cache thread-safe.

Add TinyList data structure.

Auto merge of #51225 - oli-obk:miri_oob_ptr, r=eddyb

Fix the miri submodule

cc @bjorn3

r? @eddyb

Auto merge of #51171 - faern:const-bswap-ctpop-cttz-ctlz, r=oli-obk

Make some std::intrinsics `const fn`s

Making some rustc intrinsics (`ctpop`, `cttz`, `ctlz` and `bswap`) `const fn`s.

This is a pre-step to being able to make `swap_bytes`, `to_be` and `from_be` constant functions. That in itself could be ergonomic and useful. But even better is that it would allow `Ipv4Addr::new` etc becoming `const fn`s as well. Which might be really useful since I find it quite common to want to define them as constants.

r? @oli-obk

Auto merge of #50836 - jsgf:arc-downcast, r=SimonSapin

Arc downcast

Implement `downcast` for `Arc<Any + Send + Sync>` as part of #44608, and gated by the same `rc_downcast` feature.

This PR is mostly lightly-edited cut'n'paste.

This has two additional changes:
- The `downcast` implementation needs `Any + Send + Sync` implementations for `is` and `Debug`, and I added `downcast_ref` and `downcast_mut` for completeness/consistency. (Can these be insta-stabilized?)
- At @SimonSapin's suggestion, I converted `Arc` and `Rc` to use `NonNull::cast` to avoid an `unsafe` block in each which tidied things up nicely.

Auto merge of #51096 - matthewjasper:reverse-normalization-bounds, r=nikomatsakis

Register outlives predicates from queries the right way around.

Closes #49354
The region constraints from queries need to be reversed from sub to outlives.

Note: wf checking reports these errors before NLL, so I'm not sure if there's any case when these predicates need to be created at all.

cc @nikomatsakis

Auto merge of #51257 - GuillaumeGomez:rollup, r=GuillaumeGomez

Rollup of 7 pull requests

Successful merges:

 - #49546 (Stabilize short error format)
 - #51123 (Update build instructions)
 - #51146 (typeck: Do not pass the field check on field error)
 - #51193 (Fixes some style issues in rustdoc "implementations on Foreign types")
 - #51213 (fs: copy: Use File::set_permissions instead of fs::set_permissions)
 - #51227 (mod.rs isn't beautiful)
 - #51240 (Two minor parsing tweaks)

Failed merges:

Fix up Any doc examples

Make the Any+Send+Sync examples use the right trait bounds, and fix a small whitespace issue.

Update `Arc` and `Rc` to use `NonNull::cast` to cast the inner pointers

This avoids an `unsafe` block in each case.

Implement `downcast` for `Arc<Any + Send + Sync>`

We only need to implement it for `Any + Send + Sync` because in practice
that's the only useful combination for `Arc` and `Any`.

Implementation for #44608 under the `rc_downcast` feature.

Add implementations for Any + Send + Sync

Implement `is`, `downcast_ref`, `downcast_mut` and `Debug` for
`Any + Send + Sync`.

Rollup merge of #51240 - nnethercote:parse-2, r=nikomatsakis

Two minor parsing tweaks

Rollup merge of #51227 - uuttff8:master, r=dtolnay

mod.rs isn't beautiful

I hate this spaces.

Rollup merge of #51213 - nicokoch:copy_permissions, r=cramertj

fs: copy: Use File::set_permissions instead of fs::set_permissions

We already got the open file descriptor at this point.
Don't make the kernel resolve the path again.

Rollup merge of #51193 - GuillaumeGomez:fixes-style-issues, r=QuietMisdreavus

Fixes some style issues in rustdoc "implementations on Foreign types"

Fixes #51113.

r? @QuietMisdreavus

Rollup merge of #51146 - dlrobertson:fix_51102, r=estebank

typeck: Do not pass the field check on field error

If a struct pattern has a field error return an error.

Fixes: #51102

Rollup merge of #51123 - akoserwal:master, r=Mark-Simulacrum

Update build instructions

It get stuck at the cloning step.
`./x.py build `
Updating only changed submodules
Updating submodule src/llvm
Submodule 'src/llvm' (https://github.com/rust-lang/llvm.git) registered for path 'src/llvm'
Cloning into '/home/username/rust/src/llvm'...

Rollup merge of #49546 - GuillaumeGomez:stabilize-short-error-format, r=oli-obk

Stabilize short error format

r? @oli-obk

Added in https://github.com/rust-lang/rust/pull/44636

Register outlives predicates from queries the right way around.

Update build instructions

Make short-error format GNU compatible

Stabilize short error format

Auto merge of #51050 - symphorien:fstatat, r=kennytm

std::fs::DirEntry.metadata(): use fstatat instead of lstat when possible

When reading a directory with `read_dir`, querying metadata for a resulting `DirEntry` is done by building the whole path and then `lstat`ing it, which requires the kernel to resolve the whole path. Instead, one
can use the file descriptor to the enumerated directory and use `fstatat`. This make the resolving step
unnecessary.
This PR implements using `fstatat` on linux, android and emscripten.

## Compatibility across targets
`fstatat` is POSIX.
* Linux >= 2.6.19 according to https://linux.die.net/man/2/fstatat
* android according to https://android.googlesource.com/platform/bionic/+/master/libc/libc.map.txt#392
* emscripten according to https://github.com/kripken/emscripten/blob/7f89560101843198787530731f40a65288f6f15f/system/include/libc/sys/stat.h#L76

The man page says "A similar system call exists on Solaris." but I haven't found it.

## Compatibility with old platforms
This was introduced with glibc 2.4 according to the man page. The only information I could find about the minimal version of glibc rust must support is this discussion https://internals.rust-lang.org/t/bumping-glibc-requirements-for-the-rust-toolchain/5111/10
The conclusion, if I understand correctly, is that currently rust supports glibc >= 2.3.4 but the "real" requirement is Centos 5 with glibc 2.5. This PR would make the minimal version 2.4, so this should be fine.

## Benefit
I did the following silly benchmark:
```rust
use std::io;
use std::fs;
use std::os::linux::fs::MetadataExt;
use std::time::Instant;

fn main() -> Result<(), io::Error> {
    let mut n = 0;
    let mut size = 0;
    let start = Instant::now();
    for entry in fs::read_dir("/nix/store/.links")? {
        let entry = entry?;
        let stat = entry.metadata()?;
        size += stat.st_size();
        n+=1;
    }
    println!("{} files, size {}, time {:?}", n, size, Instant::now().duration_since(start));
    Ok(())
}
```
On warm cache, with current rust nightly:
```
1014099 files, size 76895290022, time Duration { secs: 2, nanos: 65832118 }
```
(between 2.1 and 2.9 seconds usually)
With this PR:
```
1014099 files, size 76895290022, time Duration { secs: 1, nanos: 581662953 }
```
(1.5 to 1.6 seconds usually).

approximately 40% faster :)

On cold cache there is not much to gain because path lookup (which we spare) would have been a cache hit:
Before
```
1014099 files, size 76895290022, time Duration { secs: 391, nanos: 739874992 }
```
After
```
1014099 files, size 76895290022, time Duration { secs: 388, nanos: 431567396 }
```
## Testing
The tests were run on linux `x86_64`
```
python x.py test src/tools/tidy
./x.py test src/libstd
```
and the above benchmark.
I did not test any other target.

Rename num -> bits and num -> out_val

Rename bytes -> bits

libstd/sys/unix/fs.rs: fix compilation on fuchsia

Rewrite numeric_intrinsic without macro

Add test for intrinsics::bswap

Make ctpop, cttz, ctlz and bswap const fns

Auto merge of #51235 - nikomatsakis:issue-51117-borrowck-implicit-deref, r=eddyb

remove notion of Implicit derefs from mem-cat

`PointerKind` is included in `LoanPath` and hence forms part of the equality check; this led to having two unequal paths that both represent `*x`, depending on whether the `*` was inserted automatically or explicitly. Bad mojo.

Fixes #51117

r? @eddyb

typeck: Do not pass the field check on field error

If a struct pattern has a field error return an error.

change `PointerKind::Implicit` to a note

`PointerKind` is included in `LoanPath` and hence forms part of the
equality check; this led to having two unequal paths that both
represent `*x`, depending on whether the `*` was inserted
automatically or explicitly. Bad mojo. The `note` field, in contrast,
is intended more-or-less primarily for this purpose of adding extra
data.

Add std/core to prelude if extern_prelude enabled

Fixes #50605

Auto merge of #51203 - nnethercote:obligations-2, r=michaelwoerister

Two minor `obligation_forest` tweaks.

Pretty minimal improvements, but improvements nonetheless.

Auto merge of #51182 - eddyb:not-just-visibility, r=nikomatsakis

[MIR] Change "scopes" from "visibility scopes" to "source scopes".

These scopes are already used for source-oriented diagnostics, lint levels and unsafety checks.
This PR generalizes the naming around scopes, making the type `SourceScope`, and flips (across several commits) the relationship/priority between `LocalDecl`'s "visibility" and "syntactic" scopes.

r? @nikomatsakis

Update miri submodule

ScalarPair for two element tuples was treated wrongly in closure calls

Pull a layout computation out of a loop

Don't invalidate one byte beyond the end

Don't store the discriminant with the enum's type size

Update the miri submodule

Auto merge of #51127 - frewsxcv:frewsxcv-discriminant, r=GuillaumeGomez

Add doc link from discriminant struct to function.

None

Avoid an unnecessary `match` when lexing "<-".

Tweak identifer lexing.

By calling `bump()` after getting the first char, to avoid a redundant
`ident_continue()` test on it.

Add doc link from discriminant struct to function.

Auto merge of #51145 - petrochenkov:npbot, r=alexcrichton

resolve: Make sure indeterminate and inconsistent macro resolutions always generate errors

Addresses the issue described in https://github.com/rust-lang/rust/pull/50911#issuecomment-392560525

I haven't come up with a minimized reproduction yet, but confirmed that `npbot` now generates the correct error with `![feature(use_extern_macros)]`.

Auto merge of #51220 - nikomatsakis:issue-51008-false-positive-lifetime-must-be-declared, r=cramertj

reset anonymous-lifetime-mode as we enter `()` scopes

Background:

The anonymous lifetime mode is used to prohibit elided lifetimes where
they didn't used to be permitted, and instead require that `'_` be
used. For example:

```rust
impl Trait for Ref<T> { .. }
//             ^^^^^^ ERROR: should be `Ref<'_, T>`
```

When we are parsing the parts of the impl header, we enter into an alternate mode called `CreateParameter`. In this mode, we give an error for things like `Ref<T>`, but for elided lifetimes in a reference type like `&T` we make the elided lifetime into an in-band lifetime:

https://github.com/rust-lang/rust/blob/4f99f37b7e213d69a489884f651adfc6d217cef5/src/librustc/hir/lowering.rs#L4017-L4035

This was not intended to change behavior because we only enter into that mode in contexts where elision was not historically permitted. However, the problem is that we fail to reset the mode when we enter into bounds like `Fn(&u32)`, where elision *was* allowed -- the same occurs for fn types like `fn(&u32`). This PR restores the original mode in those contexts.

Fixes #51008

r? @cramertj

Inline `NodeIndex` methods.

Because they are small and hot.

Remove `ObligationForest::cache_list`.

It's never used in a meaningful way.

Auto merge of #51138 - spastorino:add-polonius-compare-mode, r=pnkfelix

Add polonius compare mode

**This is now ready to review/merge**

Auto merge of #51215 - eddyb:visit-for-a-lifetime, r=nikomatsakis

 rustc: don't visit lifetime parameters through visit_lifetime.

Ideally we'd also not use the `Lifetime` struct for parameters, but I'll leave that to @varkor (#48149).
Fixes #51185 (discovered while auditing all the `visit_lifetime` implementations).
r? @nikomatsakis

mod.rs isn't beautiful

resolve: Make sure indeterminate and inconsistent macro resolutions always generate errors

also reset anon-param-mode for `fn()` types

reset the "anonymous lifetime mode" for parenthesized where clauses

Background:

The anonymous lifetime mode is used to prohibit elided lifetimes where
they didn't used to be permitted, and instead require that `'_` be
used. For example:

```rust
impl Trait for Ref<T> { .. }
//             ^^^^^^ ERROR: should be `Ref<'_, T>`
```

When we are parsing the parts of the impl header, we enter into an
alternate mode called `CreateParameter`. In this mode, we give an
error for things like `Ref<T>`, but for elided lifetimes in a
reference type like `&T` we make the elided lifetime into an in-band
lifetime:

https://github.com/rust-lang/rust/blob/4f99f37b7e213d69a489884f651adfc6d217cef5/src/librustc/hir/lowering.rs#L4017-L4035

This was not intended to change behavior because we only enter into
that mode in contexts where elision was not historically
permitted. However, the problem is that we fail to reset the mode when
we enter into bounds like `Fn(&u32)`, where elision *was* allowed --
the same occurs for fn types like `fn(&u32`). This PR restores the
original mode in those contexts.

std::fs::DirEntry.metadata(): use fstatat instead of lstat when possible

Run rustfmt

Add compare-mode to x.py

rustc: rename mir::LocalDecl's syntactic_source_info to source_info.

rustc: turn mir::LocalDecl's visibility_source_info into a SourceScope.

rustc: use syntactic (instead of visibility) source info where appropriate.

rustc: rename mir::LocalDecl's source_info to visibility_source_info.

rustc: turn mir::LocalDecl's syntactic_scope into a SourceInfo.

rustc: rename mir::SourceScopeInfo to mir::SourceScopeLocalData.

rustc: rename mir::VisibilityScope to mir::SourceScope.

rustc: don't visit lifetime parameters through visit_lifetime.

syntax: remove overloading of fold_lifetime{,_def}{,s}.

Add polonius compare mode

Auto merge of #51100 - estebank:as-ref, r=oli-obk

Suggest using `as_ref` on some borrow errors [hack]

When encountering the following code:

```rust
struct Foo;
fn takes_ref(_: &Foo) {}
let ref opt = Some(Foo);

opt.map(|arg| takes_ref(arg));
```

Suggest using `opt.as_ref().map(|arg| takes_ref(arg));` instead.

This is a stop gap solution until we expand typeck to deal with these
cases in a more graceful way.

#43861

Suggest using `as_ref` on some borrow errors [hack]

When encountering the following code:

```rust
struct Foo;
fn takes_ref(_: &Foo) {}
let ref opt = Some(Foo);

opt.map(|arg| takes_ref(arg));
```

Suggest using `opt.as_ref().map(|arg| takes_ref(arg));` instead.

This is a stop gap solution until we expand typeck to deal with these
cases in a more graceful way.

Auto merge of #50955 - steveklabnik:update-libbacktrace, r=alexcrichton

Update libbacktrace

We haven't updated libbacktrace in two years. This is just blindly updating to the latest HEAD; I'd like to see what travis says. It at least builds on my machine, running some tests...

This perpetuates the patches from https://github.com/rust-lang/rust/pull/30908

Replace libbacktrace with a submodule

While we're at it update the `backtrace` crate from crates.io. It turns out that
the submodule's configure script has gotten a lot more finnicky as of late so
also switch over to using the `cc` crate manually which allows to avoid some
hacks around the configure script as well

std: Delete bundled libbacktrace module

Auto merge of #50880 - glandium:oom, r=SimonSapin

OOM handling changes

As discussed in https://github.com/rust-lang/rust/issues/49668#issuecomment-384893456 and subsequent.

This does have codegen implications. Even without the hooks, and with a handler that ignores the arguments, the compiler doesn't eliminate calling `rust_oom` with the `Layout`. Even if it managed to eliminate that, with the hooks, I don't know if the compiler would be able to figure out it can skip it if the hook is never set.

A couple implementation notes:
- I went with explicit enums rather than bools because it makes it clearer in callers what is being requested.
- I didn't know what `feature` to put the hook setting functions behind. (and surprisingly, the compile went through without any annotation on the functions)
- There's probably some bikeshedding to do on the naming.

Cc: @Simonsapin, @sfackler

Remobve unused import

Auto merge of #51106 - davidtwco:issue-50934, r=nikomatsakis

Optimize the way that loans are killed in borrowck dataflow

Fixes #50934.
r? @nikomatsakis

Auto merge of #51017 - estebank:crate-name-in-path, r=michaelwoerister

Use crate name for reexported `extern crate` paths

Fix #43189.

fs: copy: Use File::set_permissions instead of fs::set_permissions

We already got the open file descriptor at this point.
Don't make the kernel resolve the path again.

Auto merge of #50783 - pnkfelix:issue-27282-match-borrows-its-input-take-three, r=nikomatsakis

every match arm reads the match's borrowed input

This PR changes the `match` codegen under NLL (and just NLL, at least for now) to make the following adjustments:
 * It adds a `-Z disable-ast-check-for-mutation-in-guard` which, as described, turns off the naive (conservative but also not 100% sound) check for mutation in guards of match arms.
 * We now borrow the match input at the outset and emit a special `ReadForMatch` statement (that, according to the *static* semantics, reads that borrowed match input) at the start of each match arm. The intent here is to catch cases where the match guard mutates the match input, either via an independent borrow or via `ref mut` borrows in that arm's pattern.
 * In order to ensure that `ref mut` borrows do not actually conflict with the emitted `ReadForMatch` statements, I expanded the two-phase-borrow system slightly, and also changed the MIR code gen so that under NLL, when there is a guard on a match arm, then each pattern variable ends up having *three* temporaries associated with it:
   1. The first temporary will hold the substructure being matched; this is what we will move the (substructural) value into *if* the guard succeeds.
   2. The second temporary also corresponds to the same value as the first, but we are just constructing this temporarily for use during the scope of the guard; it is unaliased and its sole referrer is the third temporary.
   3. The third temporary is a reference to the second temporary.
   * (This sounds complicated, I know, but its actually *simpler* than what I was doing before and had checked into the repo, which was to sometimes construct the final value and then take a reference to it before evaluating the guard. See also PR #49870.)

Fix #27282

This also provides a path towards resolving #24535 aka rust-lang/rfcs#1006, at least once the `-Z disable-ast-check-for-mutation-in-guard` is just turned on by default (under NLL, that is. It is not sound under AST-borrowck).
 * But I did not want to make `#![feature(nll)]` imply that as part of this PR; that seemed like too drastic a change to me.

Add hooks allowing to override the `oom` behavior

Auto merge of #50772 - nicokoch:fastcopy, r=alexcrichton

fs: copy: use copy_file_range on Linux

Linux 4.5 introduced a new system call [copy_file_range](http://man7.org/linux/man-pages/man2/copy_file_range.2.html) to copy data from one file to another.

This PR uses the new system call (if available). This has several advantages:

1. No need to constantly copy data from userspace to kernel space, if the buffer is small or the file is large
2. On some filesystems, like BTRFS, the kernel can leverage internal fs mechanisms for huge performance gains
3. Filesystems on the network dont need to copy data between the host and the client machine (they have to in the current read/write implementation)

I have created a small library that also implements the new system call for some huge performance gains here: https://github.com/nicokoch/fastcopy
Benchmark results are in the README

Fixes some style issues in rustdoc "implementations on Foreign types"

Fix additional nits:
  - compute bytes_to_copy more elegantly
  - add assert that written is 0 in fallback case

Review feedback: Adding test cases suggested by arielb1.

Review feedback: Fix typo.

Review feedback, remove fixme comment.

Review feedback: Remove a fixme/tbd note and just add a note for the post-NLL future.

Driveby: just inline the two-line `fn inject_borrow` into its one call
site and remove its definition.

Review feedback: update fixme comment to reflect reality.

review feedback: fix indentation of pattern candidates to match code elsewhere in file.

Tests illustrating the bug fixes for #27282 and #24535.