Do not suggest adding semicolon/changing delimiters for macros in item position that originates in macros

Auto merge of #98103 - exrook:btreemap-alloc, r=Amanieu

BTreeMap: Support custom allocators (v1.5)

Related:
https://github.com/rust-lang/wg-allocators/issues/7
https://github.com/TimDiekmann/alloc-wg

Blocked on:
~~#77187~~
~~#78459~~
~~#95036~~

previous: #77438

std: Stabilize feature try_reserve_2

Signed-off-by: Xuanwo <github@xuanwo.io>

compare_const_vals: add a special case for certain ranges.

This commit removes the `a == b` early return, which isn't useful in
practice, and replaces it with one that helps matches with many ranges,
including char ranges.

compare_const_vals: Use infallible evaluation.

Because these evaluations can never fail.

Remove `ty` arg from `compare_const_vals`.

It's now only used in no-longer-interesting assertion.

Remove `from_bool` closure.

The code is clearer and simpler without it. Note that the `a == b` early
return at the top of the function means the `a == b` test at the end of
the function could never succeed.

Inline and remove `fallback` closure.

Remove one use of `compare_const_vals`.

A direct comparison has the same effect. This also avoids the need for a
type test within `compare_const_vals`.

Assert type equality of `a` and `b` in `compare_const_vals`.

Because they're always equal.

Remove dead code from `compare_const_vals`.

It's never executed when running the entire test suite. I think it's
because of the early return at the top of the function if `a.ty() != ty`
succeeds.

simplify_match_pair: avoid the second comparison if possible.

Also, the `try_to_bits` always succeeds, so use `unwrap`.

sort_candidates: avoid the second comparison if possible.

This is a performance win for `unicode-normalization`.

The commit also removes the closure, which isn't necessary. And
reformulates the comparison into a form I find easier to read.

const_range_contains: avoid the second comparison if possible.

This is a performance win for `unicode-normalization`.

Also, I find the new formulation easier to read.

Inline and remove `{enter,exit}_attrs` functions.

They each have a single call site.

Remove unused `hir_id` arg from `visit_attribute`.

Fix quadratic behaviour in the `MissingDoc` lint.

The `MissingDoc` lint has quadratic behaviour when processing doc comments.
This is a problem for large doc comments (e.g. 1000+ lines) when
`deny(missing_code)` is enabled.

A 1000-line doc comment using `//!` comments is represented as 1000 attributes
on an item. The lint machinery iterates over each attribute with
`visit_attribute`. `MissingDoc`'s impl of that function calls
`with_lint_attrs`, which calls `enter_attrs`, which iterates over all 1000
attributes looking for a `doc(hidden)` attribute. I.e. for every attribute we
iterate over all the other attributes.

The fix is simple: don't call `with_lint_attrs` on attributes. This makes
sense: `with_lint_attrs` is intended to iterate over the attributes on a
language fragment like a statement or expression, but it doesn't need to
be called on attributes themselves.

Auto merge of #98152 - JohnTitor:rollup-osr17j6, r=JohnTitor

Rollup of 7 pull requests

Successful merges:

 - #97202 (os str capacity documentation)
 - #97964 (Fix suggestions for `&a: T` parameters)
 - #98053 (Fix generic impl rustdoc json output)
 - #98059 (Inline `const_eval_select`)
 - #98092 (Fix sidebar items expand collapse)
 - #98119 (Refactor path segment parameter error)
 - #98135 (Add regression test for #93775)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

The type of the slice length field is architecture dependent

Rollup merge of #98135 - JohnTitor:issue-93022-93775, r=compiler-errors

Add regression test for #93775

Closes #93775, also closes #93022 as it should have the same root cause
r? ```@compiler-errors```

Signed-off-by: Yuki Okushi <jtitor@2k36.org>

Rollup merge of #98119 - EdwinRy:path-parenthesized-type-error, r=estebank

Refactor path segment parameter error

This PR attempts to rewrite the error handling for an unexpected parenthesised type parameters to:
- Use provided data instead of re-parsing the whole span
- Add a multipart suggestion to reflect on the changes with an underline
- Remove the unnecessary "if" nesting

Rollup merge of #98092 - GuillaumeGomez:fix-sidebar-items-expand-collapse, r=notriddle

Fix sidebar items expand collapse

The collapse/expand event was not working for the items in the source code viewer sidebar (talking about these items:


).

This PR fixes it and adds a GUI test to prevent another regression.

r? ```@notriddle```

Rollup merge of #98059 - tmiasko:inline-const-eval-select, r=Amanieu

Inline `const_eval_select`

To avoid circular link time dependency between core and compiler
builtins when building with `-Zshare-generics`.

r? ```@Amanieu```

Rollup merge of #98053 - GuillaumeGomez:fix-generic-impl-json-ice, r=notriddle

Fix generic impl rustdoc json output

Fixes #97986.

The problem in case of generic trait impl is that the trait's items are the same for all the types afterward. But since they're the same, it's safe for rustdoc-json to just ignore them.

A little representation of what's going on:

```rust
trait T {
    fn f(); // <- defid 0
}

impl<Y> T for Y {
    fn f() {} // <- defid 1
}

struct S; // <- defid 1 (since it matches `impl<Y> T for Y`
```

cc ```@Urgau```

r? ```@CraftSpider```

Rollup merge of #97964 - WaffleLapkin:fix_borrow_par_suggestions, r=compiler-errors

Fix suggestions for `&a: T` parameters

I've accidentally discovered that we have broken suggestions for `&a: T` parameters:
```rust
fn f(&mut bar: u32) {}

fn main() {
    let _ = |&mut a| ();
}
```
```text
error[E0308]: mismatched types
 --> ./t.rs:1:6
  |
1 | fn f(&mut bar: u32) {}
  |      ^^^^^^^^-----
  |      |         |
  |      |         expected due to this
  |      expected `u32`, found `&mut _`
  |      help: did you mean `bar`: `&u32`
  |
  = note:           expected type `u32`
          found mutable reference `&mut _`

error[E0308]: mismatched types
 --> ./t.rs:4:23
  |
4 |     let _: fn(u32) = |&mut a| ();
  |                       ^^^^^--
  |                       |    |
  |                       |    expected due to this
  |                       expected `u32`, found `&mut _`
  |                       help: did you mean `a`: `&u32`
  |
  = note:           expected type `u32`
          found mutable reference `&mut _`
```

It's hard to see, but
1. The help span is overlapping with "expected" spans
2. It suggests `fn f( &u32) {}` (no `mut` and lost parameter name) and `|&u32 ()` (no closing `|` and lost parameter name)

I've tried to fix this.

r? ``@compiler-errors``

Rollup merge of #97202 - joshtriplett:os-str-capacity-documentation, r=dtolnay

os str capacity documentation

This is based on https://github.com/rust-lang/rust/pull/95394 , with expansion and consolidation
to address comments from `@dtolnay` and other `@rust-lang/libs-api` team members.

Make #[cfg(bootstrap)] not error in proc macros on later stages

As was discovered in https://github.com/rust-lang/rust/pull/93628#issuecomment-1154697627 ,
adding #[cfg(bootstrap)] to a rust-internal proc macro crate
would yield an unexpected cfg name error, at least on later
stages wher the bootstrap cfg arg wasn't set.

rustc already passes arguments to mark bootstrap as expected,
however the means of delivery through the RUSTFLAGS env var
is unable to reach proc macro crates, as described
in the issue linked in the code this commit touches.

This wouldn't be an issue for cfg args that get passed through
RUSTFLAGS, as they would never become *active* either, so
any usage of one of these flags in a proc macro's code would
legitimately yield a lint warning. But since dc302587e2cf5105a3a864319d7e7bcb434bba20,
rust takes extra measures to pass --cfg=bootstrap even in
proc macros, by passing it via the wrapper. Thus, we need
to send the flags to mark bootstrap as expected also from the
wrapper, so that #[cfg(bootstrap)] also works from proc macros.

I want to thank Urgau and jplatte for helping me find the cause of this. ❤️

Auto merge of #97178 - sunfishcode:ownedfd-and-dup, r=joshtriplett

Add a `BorrowedFd::try_clone_to_owned` and accompanying documentation

Add a `BorrowedFd::try_clone_to_owned`, which returns a new `OwnedFd` sharing the underlying file description. And similar for `BorrowedHandle` and `BorrowedSocket` on WIndows.

This is similar to the existing `OwnedFd::try_clone`, but it's named differently to reflect that it doesn't return `Result<Self, ...>`. I'm open to suggestions for better names.

Also, extend the `unix::io` documentation to mention that `dup` is permitted on `BorrowedFd`.

This was originally requsted [here](https://github.com/rust-lang/rust/issues/88564#issuecomment-910786081). At the time I wasn't sure whether it was desirable, but it does have uses and it helps clarify the API. The documentation previously didn't rule out using `dup` on a `BorrowedFd`, but the API only offered convenient ways to do it from an `OwnedFd`. With this patch, the API allows one to do `try_clone` on any type where it's permitted.

Auto merge of #9002 - andylizi:fix-never-loop, r=Manishearth

Fix false positive for `never_loop` struct expression fields

Fixes #9001.

changelog: [`never_loop`]: Now checks for `continue` in struct expression

Add `#[inline]` to small fns of futex `RwLock`

The important methods like `read` and `write` were already inlined,
which can propagate all the way to inlining in user code, but these
small state functions were left behind as normal calls. They should
almost always be inlined as well, as they're just a few instructions.

Auto merge of #97665 - c410-f3r:assert-compiler, r=oli-obk

[RFC 2011] Minimal initial implementation

Tracking issue: #44838
Third step of #96496

Implementation has ~290 LOC with the bare minimum to be in a functional state. Currently only searches for binary operations to mimic what `assert_eq!` and `assert_ne!` already do.

r? `@oli-obk`

Consume resolutions for lowering separately.

Update next_node_id.

Remove unused item_generics_num_lifetimes.

Exclude cfg "doc" and "doctest" from feature `doc_auto_cfg`

Fix `cfg(not)` and `cfg(all)` causing Rustdoc stab to disappear

Add the new stability attributes, for Windows.

Revise the documentation for `try_clone`.

On Unix, describe these in terms of the underlying "file description". On
Windows, describe them in terms of the underlying "object".

Add `BorrowedFd::try_clone_to_owned`.

And `BorrowedHandle::try_clone_to_owned` and
`BorrowedSocket::try_clone_to_owned` on Windows.

Document that `BorrowedFd` may be used to do a `dup`.

debuginfo: Fix NatVis for Rc and Arc with unsized pointees.

Auto merge of #95897 - AzureMarker:feature/horizon-std, r=nagisa

STD support for the Nintendo 3DS

Rustc already supports compiling for the Nintendo 3DS using the `armv6k-nintendo-3ds` target (Tier 3). Until now though, only `core` and `alloc` were supported. This PR adds standard library support for the Nintendo 3DS. A notable exclusion is `std::thread` support, which will come in a follow-up PR as it requires more complicated changes.

This has been a joint effort by `@Meziu,` `@ian-h-chamberlain,` myself, and prior work by `@rust3ds` members.

### Background

The Nintendo 3DS (Horizon OS) is a mostly-UNIX looking system, with the caveat that it does not come with a full libc implementation out of the box. On the homebrew side (I'm not under NDA), the libc interface is partially implemented by the [devkitPro](https://devkitpro.org/wiki/devkitPro_pacman) toolchain and a user library like [`libctru`](https://github.com/devkitPro/libctru). This is important because there are [some possible legal barriers](https://github.com/rust-lang/rust/pull/88529#issuecomment-919938396) to linking directly to a library that uses the underlying platform APIs, since they might be considered a trade secret or under NDA.

To get around this, the standard library impl for the 3DS does not directly depend on any platform-level APIs. Instead, it expects standard libc functions to be linked in. The implementation of these libc functions is left to the user. Some functions are provided by the devkitPro toolchain, but in our testing, we used the following to fill in the other functions:
- [`libctru`] - provides more basic APIs, such as `nanosleep`. Linked in by way of [`ctru-sys`](https://github.com/Meziu/ctru-rs/tree/master/ctru-sys).
- [`pthread-3ds`](https://github.com/Meziu/pthread-3ds) - provides pthread APIs for `std::thread`. Implemented using [`libctru`].
- [`linker-fix-3ds`](https://github.com/Meziu/rust-linker-fix-3ds) - fulfills some other missing libc APIs. Implemented using [`libctru`].

For more details, see the `src/doc/rustc/src/platform-support/armv6k-nintendo-3ds.md` file added in this PR.

### Notes
We've already upstreamed changes to the [`libc`] crate to support this PR, as well as the upcoming threading PR. These changes have all been released as of 0.2.121, so we bump the crate version in this PR.
Edit: After some rebases, the version bump has already been merged so it doesn't appear in this PR.

A lot of the changes in this PR are straightforward, and follow in the footsteps of the ESP-IDF target: https://github.com/rust-lang/rust/pull/87666.

The 3DS does not support user space process spawning, so these APIs are unimplemented (similar to ESP-IDF).

[`libctru`]: https://github.com/devkitPro/libctru
[`libc`]: https://github.com/rust-lang/libc

Add regression test for #93775

Signed-off-by: Yuki Okushi <jtitor@2k36.org>

Auto merge of #98131 - JohnTitor:rollup-c17vjdy, r=JohnTitor

Rollup of 3 pull requests

Successful merges:

 - #95118 (Implement stabilization of `#[feature(io_safety)]`.)
 - #98110 (Make `ExprKind::Closure` a struct variant.)
 - #98115 (Remove `rustc_deprecated` diagnostics)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

[RFC 2011] Minimal initial implementation

Rollup merge of #98115 - jhpratt:remove-rustc_deprecated, r=compiler-errors

Remove `rustc_deprecated` diagnostics

Follow-up on #95960. The diagnostics will remain until the next bootstrap, at which point people will have had six weeks to adjust.

``@rustbot`` label +A-diagnostics

r? ``@compiler-errors``

Rollup merge of #98110 - cjgillot:closure-brace, r=Aaron1011

Make `ExprKind::Closure` a struct variant.

Simple refactor since we both need it to introduce additional fields in `ExprKind::Closure`.

r? ``@Aaron1011``

Rollup merge of #98110 - cjgillot:closure-brace, r=Aaron1011

Make `ExprKind::Closure` a struct variant.

Simple refactor since we both need it to introduce additional fields in `ExprKind::Closure`.

r? ``@Aaron1011``

Rollup merge of #95118 - sunfishcode:sunfishcode/stabilize-io-safety, r=joshtriplett

Implement stabilization of `#[feature(io_safety)]`.

Implement stabilization of [I/O safety], aka `#[feature(io_safety)]`.

Fixes #87074.

[I/O safety]: https://github.com/rust-lang/rfcs/blob/master/text/3128-io-safety.md

Fix false positive for `never_loop` struct expression fields

Test NLL fix of bad lifetime inference for reference captured in closure.

Auto merge of #98084 - nnethercote:rm-thread-local-IGNORED_ATTRIBUTES, r=michaelwoerister

Remove thread-local `IGNORED_ATTRIBUTES`.

It's just a copy of the read-only global `ich::IGNORED_ATTRIBUTES`, and
can be removed without any effect.

r? `@michaelwoerister`

change "1" to "c" to pass test

Incorrectly wrote "1" twice when writing test.

Add examples using `add_modify` to btree

Updated the btree's documentation to include two references to
add_modify.

The first is when the `Entry` API is mentioned at the beginning. With
the same reasoning as HashMap's documentation, I thought it would best
to keep `attack`, but show the `mana` example.

The second is with the `entry` function that is used for the `Entry`
API. The code example was a perfect use for `add_modify`, which is why
it was changed to reflect that.

Add examples using `add_modify` to HashMap

Updated the HashMap's documentation to include two references to
add_modify.

The first is when the `Entry` API is mentioned at the beginning. I was
hesitant to change the "attack" example (although I believe that it is
perfect example of where `add_modify` should be used) because both uses
work equally, but one is more idiomatic (`add_modify`).

The second is with the `entry` function that is used for the `Entry`
API. The code example was a perfect use for `add_modify`, which is why
it was changed to reflect that.

Auto merge of #8964 - tamaroning:read_zero_byte_vec, r=dswij

Warn about read into zero-length `Vec`

Closes #8886

- \[x] Followed [lint naming conventions][lint_naming]
- \[x] Added passing UI tests (including committed `.stderr` file)
- \[x] `cargo test` passes locally
- \[x] Executed `cargo dev update_lints`
- \[x] Added lint documentation
- \[x] Run `cargo dev fmt`

changelog: none

Auto merge of #98123 - JohnTitor:rollup-rfg1a4s, r=JohnTitor

Rollup of 7 pull requests

Successful merges:

 - #97822 (Filter out intrinsics if we have other import candidates to suggest)
 - #98026 (Move some tests to more reasonable directories)
 - #98067 (compiler: remove unused deps)
 - #98078 (Use unchecked mul to compute slice sizes)
 - #98083 (Rename rustc_serialize::opaque::Encoder as MemEncoder.)
 - #98087 (Suggest adding a `#[macro_export]` to a private macro)
 - #98113 (Fix misspelling of "constraint" as "contraint")

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Rollup merge of #98113 - EdwinRy:constraint-misspelling, r=compiler-errors

Fix misspelling of "constraint" as "contraint"

I misspelled a function name a while back

Rollup merge of #98087 - TaKO8Ki:suggest-adding-macro-export, r=oli-obk

Suggest adding a `#[macro_export]` to a private macro

fixes #97628

Rollup merge of #98083 - nnethercote:rename-Encoder, r=bjorn3

Rename rustc_serialize::opaque::Encoder as MemEncoder.

This avoids the name clash with `rustc_serialize::Encoder` (a trait),
and allows lots qualifiers to be removed and imports to be simplified
(e.g. fewer `as` imports).

(This was previously merged as commit 5 in #94732 and then was reverted
in #97905 because of a perf regression caused by commit 4 in #94732.)

r? ```@bjorn3```

Rollup merge of #98078 - erikdesjardins:uncheckedsize, r=petrochenkov

Use unchecked mul to compute slice sizes

This allows LLVM to realize that `slice.len() > 0` iff `slice.len() * size_of::<T>() > 0`, allowing a branch on the latter to be folded into the former when dropping vecs and boxed slices, in some cases.

Fixes (partially) #96497

Rollup merge of #98067 - klensy:compiler-deps2, r=Dylan-DPC

compiler: remove unused deps

Removed unused dependencies in compiler crates and moves few `libc` under `target.cfg(unix)` .

Rollup merge of #98026 - c410-f3r:z-errors, r=petrochenkov

Move some tests to more reasonable directories

r? ```@petrochenkov```

Rollup merge of #97822 - compiler-errors:hesitate-to-suggest-intrinsics, r=oli-obk

Filter out intrinsics if we have other import candidates to suggest

Fixes #97618

Also open to just sorting these candidates to be last. Pretty easy to modify the code to do that, too.

Auto merge of #97474 - compiler-errors:if-cond-and-block, r=oli-obk

Improve parsing errors and suggestions for bad `if` statements

1. Parses `if {}` as `if <err> {}` (block-like conditions that are missing a "then" block), and `if true && {}` as `if true && <err> {}` (unfinished binary operation), which is a more faithful recovery and leads to better typeck errors later on.
1. Points out the span of the condition if we don't see a "then" block after it, to help the user understand what is being parsed as a condition (and by elimination, what isn't).
1. Allow `if cond token else { }` to be fixed properly to `if cond { token } else { }`.
1. Fudge with the error messages a bit. This is somewhat arbitrary and I can revert my rewordings if they're useless.

----

Also this PR addresses a strange parsing regression (1.20 -> 1.21) where we chose to reject this piece of code somewhat arbitrarily, even though we should parse it fine:

```rust
fn main() {
    if { if true { return } else { return }; } {}
}
```

For context, all of these other expressions parse correctly:

```rust
fn main() {
    if { if true { return } else { return } } {}
    if { return; } {}
    if { return } {}
    if { return if true { } else { }; } {}
}
```

The parser used a heuristic to determine if the "the parsed `if` condition makes sense as a condition" that did like a one-expr-deep reachability analysis. This should not be handled by the parser though.

`BitSet` perf improvements

This commit makes two changes:
 1. Changes `MaybeLiveLocals` to use `ChunkedBitSet`
 2. Overrides the `fold` method for the iterator for `ChunkedBitSet`

proc_macro: support encoding/decoding Vec<T>

proc_macro: support encoding/decoding structs with type parameters

Refactor path segment parameter error

rename function and remove return type

Remove `rustc_deprecated` diagnostics

Add a stability attribute to WASI's `try_clone()`.

Implement stabilization of `#[feature(io_safety)]`.

Implement stabilization of [I/O safety], aka `#[feature(io_safety)]`.

Fixes #87074.

[I/O safety]: https://github.com/rust-lang/rfcs/blob/master/text/3128-io-safety.md

Auto merge of #96285 - flip1995:pk-vfe, r=nagisa

Introduce `-Zvirtual-function-elimination` codegen flag

Fixes #68262

This PR adds a codegen flag `-Zvirtual-function-elimination` to enable the VFE optimization in LLVM. To make this work, additonal  information has to be added to vtables ([`!vcall_visibility` metadata](https://llvm.org/docs/TypeMetadata.html#vcall-visibility-metadata) and a `typeid` of the trait). Furthermore, instead of just `load`ing functions, the [`llvm.type.checked.load` intrinsic](https://llvm.org/docs/LangRef.html#llvm-type-checked-load-intrinsic) has to be used to map functions to vtables.

For technical details of the changes, see the commit messages.

I also tested this flag on https://github.com/tock/tock on different boards to verify that this fixes the issue https://github.com/tock/tock/issues/2594. This flag is able to improve the size of the resulting binary by about 8k-9k bytes by removing the unused debug print functions.

[Rendered documentation update](https://github.com/flip1995/rust/blob/pk-vfe/src/doc/rustc/src/codegen-options/index.md#virtual-function-elimination)

rustdoc: add test case for "variadic tuple" search notation

use unchecked mul to compute slice sizes

...since slice sizes can't signed wrap

see https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html

> The total size len * mem::size_of::<T>() of the slice must be no larger than isize::MAX.

Separate `source_span` and `expn_that_defined` from `Definitions`.

Do not modify the resolver outputs.

Make ResolverAstLowering a struct.

Separate Definitions and CrateStore from ResolverOutputs.

rustdoc: change "variadic tuple" notation to look less like real syntax

Add GUI test for sidebar items expand/collapse

btreemap-alloc: adjust ui test

btreemap-alloc: fix clear impl

BTreeMap: Add alloc param

Auto merge of #96591 - b-naber:transition-to-valtrees-in-type-system, r=lcnr

Use valtrees as the type-system representation for constant values

This is not quite ready yet, there are still some problems with pretty printing and symbol mangling and `deref_const` seems to not work correctly in all cases.

Mainly opening now for a perf-run (which should be good to go, despite the still existing problems).

r? `@oli-obk`

cc `@lcnr` `@RalfJung`

Auto merge of #8999 - Alexendoo:error-pattern, r=xFrednet

Remove error-pattern comments

The `clippy_lints` one [is unused](https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/.60error-pattern.60), the others in `ui-toml` also appear not to have an effect

changelog: none

Remove error-pattern comments

rebase

add a test case for `decl_macro`

implement `MacroData`

add lint

account for endianness in debuginfo for const args

rebase

correctly create Scalar for meta info

fix wrong evaluation in clippy

fix wrong evaluation in clippy

address review

address review

bless 32-bit ui tests