Auto merge of #65874 - Nadrieril:clarify-usefulness, r=varkor

Clarify pattern-matching usefulness algorithm

This PR clarifies a bit the usefulness algorithm by emphasizing that each row of the matrix can be seen as a sort of stack from which we pop constructors. It also moves code around to increase separation of concerns.

This is part of my splitting of https://github.com/rust-lang/rust/pull/65160 into smaller PRs.

Minor style improvements

Co-Authored-By: Ralf Jung <post@ralfj.de>

Use any() in code shared between FreeBSD and NetBSD

Use KERN_ARND syscall for random numbers on NetBSD, same as FreeBSD.

This system call is present on all supported NetBSD versions and
provides an endless stream of non-blocking random data from the
kernel's ChaCha20-based CSPRNG. It doesn't require a file descriptor
to be opened.

The system call is documented here (under kern.arandom):
https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7+NetBSD-7.0

And defined here:
https://nxr.netbsd.org/xref/src/sys/sys/sysctl.h#273

The semantics are the same as FreeBSD so reading 256 bytes per call
is fine.

Similar change for getrandom crate: rust-random/getrandom#115

Implemented the home_dir for VxWorks

bump smallvec to 1.0

Do not require extra LLVM backends for `x.py test` to pass

also test different integers

test offset_from with two integers

Miri: ptr_offset_from: support offset_from with twice the same non-null integer

Miri: offset_from: do int-to-ptr casts when needed

clean highlightSourceLines code

Auto merge of #66078 - petrochenkov:gateout, r=Centril

expand: Feature gate out-of-line modules in proc macro input

Extracted from https://github.com/rust-lang/rust/pull/64273.

We are currently gating attributes applied directly to `mod` items because there are unresolved questions about out-of-line modules and their behavior is very likely to change.

However, you can sneak an out-of-line module into an attribute macro input using modules nested into other items like
```rust
#[my_attr]
fn m() {
    #[path = "zzz.rs"]
    mod n; // what tokens does the `my_attr` macro see?
}
```
This PR prevents that and emits a feature gate error for this case as well.

r? @Centril
It would be great to land this before beta.

expand: Feature gate out-of-line modules in proc macro input

let caller of check_ptr_access_align control the error message

also explain how to resolve MethodCall

more robust method checking through DefId and diagnostic_item

more correct error msg

avoid using nightly features

Auto merge of #65835 - Mark-Simulacrum:lockless-lintbuffer, r=nikomatsakis

Remove LintBuffer from Session

This moves the `LintBuffer` from `Session` into the `Resolver`, where it is used until lowering is done and then consumed by early lint passes. This also happily removes the failure mode of buffering lints too late where it would have previously lead to ICEs; it is statically no longer possible to do so.

I suspect that with a bit more work a similar move could be done for the lint buffer inside `ParseSess`, but this PR doesn't touch it (in part to keep itself small).

The last commit is the "interesting" commit -- the ones before it don't work (though they compile) as they sort of prepare the various crates for the lint buffer to be passed in rather than accessed through Session.

QPath docs: mention how to resolve them

Auto merge of #64878 - XAMPPRocky:relnotes-1.39.0, r=XAMPPRocky

Updated RELEASES.md for 1.39.0

### [Rendered](https://github.com/XAMPPRocky/rust/blob/relnotes-1.39.0/RELEASES.md)

r? @Mark-Simulacrum
cc @rust-lang/release

librustc_lexer: Make nth_char method private

librustc_lexer: Reorder imports in lib.rs

librustc_lexer: Simplify "lifetime_or_char" method

use silent emitter for rustdoc highlighting pass

Delete lint buffer from Session

Move crate type checking later

This allows us to directly pass in a lint buffer

Utilize Resolver lint buffer during HIR lowering

Migrate resolver over to internal lint buffer

Only permit taking buffered lints inside lint internals

Remove unused get_any method

Auto merge of #65838 - estebank:resilient-recovery, r=Centril

Reduce amount of errors given unclosed delimiter

When in a file with a non-terminated item, catch the error and consume
the block instead of trying to recover it on a more granular way in order to
reduce the amount of unrelated errors that would be fixed after adding
the missing closing brace. Also point out the possible location of the
missing closing brace.

Fix #63690.

Auto merge of #65780 - GuillaumeGomez:move-help-popup-generation-code, r=Mark-Simulacrum

Move help popup generation code

The first commit is just a small cleanup.

The idea behind this PR is to reduce a bit more the generated HTML files by moving the duplicated code into one place instead.

r? @kinnison

Do not needlessly write-lock

Don't extend lifetime of temp in `Repeat` expressions

Test that borrows of projections are promoted everywhere

Previously, this worked in `fn`s but not `const`s or `static`s.

Mark entire local as promoted even if only part is used

Auto merge of #65646 - Amanieu:foreign-exceptions, r=nikomatsakis

Allow foreign exceptions to unwind through Rust code and Rust panics to unwind through FFI

This PR fixes interactions between Rust panics and foreign (mainly C++) exceptions.

C++ exceptions (and other FFI exceptions) can now safely unwind through Rust code:
- The FFI function causing the unwind must be marked with `#[unwind(allowed)]`. If this is not the case then LLVM may optimize landing pads away with the assumption that they are unreachable.
- Drop code will be executed as the exception unwinds through the stack, as with a Rust panic.
- `catch_unwind` will *not* catch the exception, instead the exception will silently continue unwinding past it.

Rust panics can now safely unwind through C++ code:
- C++ destructors will be called as the stack unwinds.
- The Rust panic can only be caught with `catch (...)`, after which it can be either rethrown or discarded.
- C++ cannot name the type of the Rust exception object used for unwinding, which means that it can't be caught explicitly or have its contents inspected.

Tests have been added to ensure all of the above works correctly.

Some notes about non-C++ exceptions:
- `pthread_cancel` and `pthread_exit` use unwinding on glibc. This has the same behavior as a C++ exception: destructors are run but it cannot be caught by `catch_unwind`.
- `longjmp` on Windows is implemented using unwinding. Destructors are run on MSVC, but not on MinGW. In both cases the unwind cannot be caught by `catch_unwind`.
- As with C++ exceptions, you need to mark the relevant FFI functions with `#[unwind(allowed)]`, otherwise LLVM will optimize out the destructors since they seem unreachable.

I haven't updated any of the documentation, so officially unwinding through FFI is still UB. However this is a step towards making it well-defined.

Fixes #65441

cc @gnzlbg
r? @alexcrichton

Configure LLVM module PIC level

As of LLVM 9, this is required for 32-bit PowerPC to properly generate
PLT references. Previously, only BigPIC was supported; now LLVM supports
both BigPIC and SmallPIC, and there is no default value provided.

Auto merge of #65759 - tmiasko:ui, r=petrochenkov

Validate error patterns and error annotation in ui tests when present

Previously, when compilation succeeded, neither error patterns nor error
annotation would be validated. Additionally, when compilation failed,
only error patterns would be validated if both error patterns and error
annotation were present.

Now both error patterns and error annotation are validated when present,
regardless of compilation status. Furthermore, for test that should run,
the error patterns are matched against executable output, which is what
some of tests already expect to happen, and when #65506 is merged even
more ui tests will.

Fixes #56277

Fix macOS tests

Make Emscripten unwinding use a valid type_info

This allows catch_panic to ignore C++ exceptions.

Make SEH exceptions use a rust_panic type instead of unsigned __int64*

Hack to make C++ exceptions test work on i686-pc-windows-gnu

Allow foreign exceptions to unwind through Rust code

Enable C++ exceptions on MSVC when building C++ tests

Add -lstdc++ for run-make-fulldeps tests on MinGW

Attempt to clarify LTO and codegen-units.

syntax: Avoid span arithmetics for delimiter tokens

Auto merge of #65827 - AnthonyMikh:out_of_the_loop, r=estebank

Remove a loop which runs exactly once

Though the code seems to work properly, it is worth removing the loop entirely in order to not confuse the reader.

r? @estebank

don't fail manifest creation if the toolstate file is missing or mal-formed

when Miri tests are not passing, do not add Miri component

librustc_lexer: Simplify "raw_double_quoted_string" method

librustc_lexer: Simplify "double_quoted_string" method

librustc_lexer: Simplify "single_quoted_string" method

Use check-pass for never type tests

Avoid matching type in huge-struct test error annotation

The concrete type that will be too big is target dependent. Avoid
matching it in error annotation to make test work correctly across
different targets.

Update error annotations in ui-fulldeps tests that successfully compile

Validate error patterns and error annotation in ui tests when present

Previously, when compilation succeeded, neither error patterns nor error
annotation would be validated. Additionally, when compilation failed,
only error patterns would be validated if both error patterns and error
annotation were present.

Now both error patterns and error annotation are validated when present,
regardless of compilation status. Furthermore, for test that should run,
the error patterns are matched against executable output, which is what
some of tests already expect to happen, and when #65506 is merged even
more ui tests will.

Update error annotations positions

Since 8ec9d7242c3352fbc617d907bec3632215811356, in the case of a local
macro expansion, the errors are now matched to macro definition
location. Update test cases accordingly.

Avoid mixing error patterns with error annotations

When both error patterns and error annotations are present in an ui
test, only error patterns are validated against the output.

Replace the error pattern with an error annotation to avoid silently
ignoring the other error annotation.

librustc_lexer: Make "eat_float_exponent" return bool instead of result

librustc_lexer: Introduce "eat_while" and "eat_identifier" methods

librustc_lexer: Add methods "first" and "second" to the "Cursor"

Auto merge of #65779 - kevgrasso:E0308highlight, r=estebank

Highlight only relevant parts of type path in type errors

Resolves #57413.

Unfortunately the current Rust UI testing setup can't test that the correct colors are being used in a given output, so here's a screenshot of a small test program I wrote:

rustc_codegen_ssa: rename FnTypeLlvmExt to FnAbiLlvmExt.

rustc_codegen_ssa: rename ArgTypeMethods to ArgAbiMethods.

rustc: rename {Fn,Arg}TypeExt to {Fn,Arg}AbiExt.

rustc_target: rename {Fn,Arg}Type to {Fn,Arg}Abi.

Auto merge of #63810 - oli-obk:const_offset_from, r=RalfJung,nikic

Make <*const/mut T>::offset_from `const fn`

This reenables offset_of cc @mjbshaw  after https://github.com/rust-lang/rust/pull/63075 broke it

adjust for missing spans on x86 test runner

Don't double-count `simd_shuffle` promotion candidates

The proper attribute was added to `simd_shuffle*` in
rust-lang/stdarch#825. This caused `promote_consts` to double-count its
second argument when recording promotion candidates, which caused
the promotion candidate compatibility check to fail.

Auto merge of #65429 - Timmmm:withoptions, r=Mark-Simulacrum

Add File::with_options

This provides a more fluent API to create files with options, and also avoids the need to import OpenOptions.

This implements @aldanor's [suggestion](https://github.com/rust-lang/rfcs/pull/2615#issuecomment-448591304) which was popular.

also identiy MaybeUninit::uninit().assume_init() as dangerous

Add FFI bindings for Module::getInstructionCount()

Just to make it useable for profiling and such inside
rustc itself.  It was vaguely useful in
https://wiki.alopex.li/WhereRustcSpendsItsTime and I figured
I might as well upstream it; I may or may not ever get around
to doing more with it (hopefully I will), but it may be useful
for others.

Rename SuperiorThanZero -> GreaterThanZero

uninit/zeroed lint: warn against NULL vtables

Suggest more likely code when encountering an incorrect assoc item referencing the current trait

Auto merge of #66004 - eddyb:revert-early-gate, r=petrochenkov

Partially revert the early feature-gatings added in #65742.

The intent here is to address #65860 ASAP (in time for beta, ideally), while leaving as much of #65742 around as possible, to make it easier to re-enable later.

Therefore, I've only kept the parts of the revert that re-add the old (i.e. non-early) feature-gating checks that were removed in #65742, and the test reverts.

I've disabled the new early feature-gating checks from #65742 entirely for now, but it would be easy to put them behind a `-Z` flag, or turn them into warnings, which would allow us to keep tests for both the early and late versions of the checks - assuming that's desirable.

cc @nikomatsakis @Mark-Simulacrum @Centril

Update error annotations in tests that successfully compile

Those annotation are silently ignored rather than begin validated
against compiler output. Update them before validation is enabled,
to avoid test failures.

Remove erroneous error-pattern from run-pass test

Suggest correct code when encountering an incorrect trait bound referencing the current trait

Prettify mismatched types error message in a special case

Type parameters are referenced in the error message after the previous
few commits (using span label). But when the main error message already
references the very same type parameter it becomes clumsy. Do not show
the additional label in this case as per code review comment by
@estebank.

Also this contains a small style fix.

Update tests

Update the tests to reflect changes to how type mismatch errors are
reported (two previous commits).

Show type param definitions in type mismatch errors

Fixes #47319.

Shows the type parameter definition(s) on type mismatch errors so the
context is clearer. Pretty much changes the following:

```
LL |     bar1(t);
   |          ^
   |          |
   |          expected enum `std::option::Option`, found type parameter `T`
```

into:

```
LL | fn foo1<T>(t: T) {
   |         - this type parameter
LL |     bar1(t);
   |          ^
   |          |
   |          expected enum `std::option::Option`, found type parameter `T`
```

Add type parameter name to type mismatch error messages

Part of #47319.

This just adds type parameter name to type mismatch error message, so
e.g. the following:

```
expected enum `std::option::Option`, found type parameter
```

becomes

```
expected enum `std::option::Option`, found type parameter `T`
```

doc(str): show example of chars().count() under len()

the docs are great at explaining that .len() isn't like in other
languages but stops short of explaining how to get the character length.

r? @steveklabnik

Move has_panic_handler to query

Remove the `AsRef` impl for `SymbolStr`.

Because it's highly magical, which goes against the goal of keeping
`SymbolStr` simple. Plus it's only used in a handful of places that
only require minor changes.

Simplify various `Symbol` use points.

Including removing a bunch of unnecessary `.as_str()` calls, and a bunch
of unnecessary sigils.

Convert `x.as_str().to_string()` to `x.to_string()` where possible.

Remove some unnecessary renamings of constants.

Add some explanatory comments.

Remove an erroneous comment.

Rename `LocalInternedString` as `SymbolStr`.

It makes the relationship with `Symbol` clearer. The `Str` suffix
matches the existing `Symbol::as_str()` method nicely, and is also
consistent with it being a wrapper of `&str`.

`Span` cannot represent `span.hi < span.lo`

So we can remove the corresponding checks from various code

Auto merge of #66021 - tmandry:rollup-y13l6n9, r=tmandry

Rollup of 16 pull requests

Successful merges:

 - #65112 (Add lint and tests for unnecessary parens around types)
 - #65470 (Don't hide ICEs from previous incremental compiles)
 - #65471 (Add long error explanation for E0578)
 - #65857 (rustdoc: Resolve module-level doc references more locally)
 - #65902 (Make ItemContext available for better diagnositcs)
 - #65914 (Use structured suggestion for unnecessary bounds in type aliases)
 - #65946 (Make `promote_consts` emit the errors when required promotion fails)
 - #65960 (doc: reword iter module example and mention other methods)
 - #65963 (update submodules to rust-lang)
 - #65972 (Fix libunwind build: Define __LITTLE_ENDIAN__ for LE targets)
 - #65977 (Fix incorrect diagnostics for expected type in E0271 with an associated type)
 - #65995 (Add error code E0743 for "C-variadic has been used on a non-foreign function")
 - #65997 (Fix outdated rustdoc of Once::init_locking function)
 - #66002 (Stabilize float_to_from_bytes feature)
 - #66005 (vxWorks: remove code related unix socket)
 - #66018 (Revert PR 64324: dylibs export generics again (for now))

Failed merges:

r? @ghost

Rollup merge of #66018 - pnkfelix:issue-64872-revert-64324, r=alexcrichton

Revert PR 64324: dylibs export generics again (for now)

As discussed on PR #65781, this is a targeted attempt to undo the main semantic change from PR #64324, by putting `dylib` back in the set of crate types that export generic symbols.

The main reason to do this is that PR #64324 had unanticipated side-effects that caused bugs like #64872, and in the opinion of @alexcrichton and myself, the impact of #64872 is worse than #64319.

In other words, it is better for us, in the short term, to reopen #64319 as currently unfixed for now than to introduce new bugs like #64872.

Fix #64872

Reopen #64319

Rollup merge of #66005 - Wind-River:master_base, r=alexcrichton

vxWorks: remove code related unix socket

r? @alexcrichton