Rollup merge of #100590 - TaKO8Ki:suggest-adding-array-length, r=compiler-errors

Suggest adding an array length if possible

fixes #100448

Rollup merge of #100567 - Rageking8:fix-100563, r=wesleywiser

Add missing closing quote

fixes #100563

Rollup merge of #100460 - cuviper:drop-llvm-12, r=nagisa

Update the minimum external LLVM to 13

With this change, we'll have stable support for LLVM 13 through 15 (pending release).
For reference, the previous increase to LLVM 12 was #90175.

r? `@nagisa`

Rollup merge of #100384 - ridwanabdillahi:instr_profile_output, r=wesleywiser

Add support for generating unique profraw files by default when using `-C instrument-coverage`

Currently, enabling the rustc flag `-C instrument-coverage` instruments the given crate and by default uses the naming scheme `default.profraw` for any instrumented profile files generated during the execution of a binary linked against this crate. This leads to multiple binaries being executed overwriting one another and causing only the last executable run to contain actual coverage results.

This can be overridden by manually setting the environment variable `LLVM_PROFILE_FILE` to use a unique naming scheme.

This PR adds a change to add support for a reasonable default for rustc to use when enabling coverage instrumentation similar to how the Rust compiler treats generating these same `profraw` files when PGO is enabled.

The new naming scheme is set to `default_%m_%p.profraw` to ensure the uniqueness of each file being generated using [LLVMs special pattern strings](https://clang.llvm.org/docs/SourceBasedCodeCoverage.html#running-the-instrumented-program).

Today the compiler sets the default for PGO `profraw` files to `default_%m.profraw` to ensure a unique file for each run. The same can be done for the instrumented profile files generated via the `-C instrument-coverage` flag as well which LLVM has API support for.

Linked Issue: https://github.com/rust-lang/rust/issues/100381

r? `@wesleywiser`

Rollup merge of #100338 - lyming2007:issue-100285-fix, r=petrochenkov

when there are 3 or more return statements in the loop

emit the first 3 errors and duplicated diagnostic information
modified:   compiler/rustc_typeck/src/check/coercion.rs
new file:   src/test/ui/typeck/issue-100285.rs
new file:   src/test/ui/typeck/issue-100285.stderr

Auto merge of #100007 - ChrisDenton:dtor-inline-never, r=michaelwoerister

Never inline Windows dtor access

Inlining can cause problem If used in a Rust dylib. See #44391.

r? `@Mark-Simulacrum`

when there are 3 or more return statements in the loop
emit the first 3 errors and duplicated diagnostic information
using take of iterator for the first third return
modified:   compiler/rustc_typeck/src/check/coercion.rs
new file:   src/test/ui/typeck/issue-100285.rs
new file:   src/test/ui/typeck/issue-100285.stderr

use `span_suggestion` instead of `span_suggestion_verbose`

Auto merge of #100595 - matthiaskrgr:rollup-f1zur58, r=matthiaskrgr

Rollup of 10 pull requests

Successful merges:

 - #100031 (improve "try ignoring the field" diagnostic)
 - #100325 (Rustdoc-Json: Don't remove impls for items imported from private modules)
 - #100377 (Replace - with _ in fluent slugs to improve developer workflows)
 - #100458 (Adjust span of fn argument declaration)
 - #100514 (Delay span bug when failing to normalize negative coherence impl subject due to other malformed impls)
 - #100528 (Support 1st group of RISC-V Bitmanip backend target features)
 - #100559 (Parser simplifications)
 - #100568 (Fix STD build for ESP-IDF)
 - #100582 ([rustdoc] Fix handling of stripped enum variant in JSON output format)
 - #100586 (Reland changes replacing num_cpus with available_parallelism )

Failed merges:

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

Rollup merge of #100586 - the8472:available_parallelism_2, r=jyn514

Reland changes replacing num_cpus with available_parallelism

Since #97925 added cgroupv1 support the problem in #97549 which lead to the previous revert should be addressed now.

Cargo has reapplied the replacement too https://github.com/rust-lang/cargo/pull/10969

Reverts 1ae4b258267462da0b1aae1badcf83578153c799 (part of #97911)
Relands #94524

Rollup merge of #100582 - GuillaumeGomez:rustdoc-json-stripped-enum-variant, r=notriddle

[rustdoc] Fix handling of stripped enum variant in JSON output format

Fixes https://github.com/rust-lang/rust/issues/100529.

cc ``@aDotInTheVoid`` ``@Enselic``
r? ``@notriddle``

Rollup merge of #100568 - ivmarkov:master, r=Mark-Simulacrum

Fix STD build for ESP-IDF

We have accidentally broken the STD build for the Tier 3 `target_os="espidf"` (only) by pushing non-buildable changes to `libc` which ended up in version 0.2.229.

`libc` [was fixed](https://github.com/rust-lang/libc/commit/d0e3ff01a808d429baf925bf0e6e5f2273de1ac0) from V0.2.230 onwards. This PR is only upgrading the `libc` dependency in `Cargo.lock` to latest (V0.2.231).

`Cargo.lock` was modified by using `cargo update -p libc`.

Rollup merge of #100559 - nnethercote:parser-simplifications, r=compiler-errors

Parser simplifications

Best reviewed one commit at a time.

r? ``@compiler-errors``

Rollup merge of #100528 - tux3:riscv-bitmanip-features, r=davidtwco

Support 1st group of RISC-V Bitmanip backend target features

These target features use the same names as LLVM and `is_riscv_feature_detected!`, they are:
- zba (address generation instructions)
- zbb (basic bit manipulation)
- zbc (carry-less multiplication)
- zbs (single-bit manipulation)

The extension is frozen and ratified, and I don't think we should expect LLVM to change those feature names in the future.
For reference, the specification for the B extension can be found here: https://github.com/riscv/riscv-bitmanip/releases/download/1.0.0/bitmanip-1.0.0-38-g865e7a7.pdf)

On my current project, I see a 7.6% reduction in binary size with these features on, so I have some incentive to try to silence the "unknown feature" warning from `-Ctarget-feature` =)

Rollup merge of #100514 - compiler-errors:issue-100191, r=spastorino

Delay span bug when failing to normalize negative coherence impl subject due to other malformed impls

Fixes #100191

r? ``@spastorino``

Rollup merge of #100458 - compiler-errors:fn-argument-span, r=estebank

Adjust span of fn argument declaration

Span of a fn argument declaration goes from:

```
fn foo(i : i32 , ...)
       ^^^^^^^^
```

to:

```
fn foo(i : i32 , ...)
       ^^^^^^^
```

That is, we don't include the extra spacing up to the trailing comma, which I think is more correct.

cc https://github.com/rust-lang/rust/pull/99646#discussion_r944568074
r? ``@estebank``

---

The two tests that had dramatic changes in their rendering I think actually are improved, though they are kinda poor spans both before and after the changes. :shrug: Thoughts?

Rollup merge of #100377 - est31:fluent_grepability, r=davidtwco

Replace - with _ in fluent slugs to improve developer workflows

This is a proposal to smoothen the compiler contribution experience in the face of the move to fluent.

## Context

The fluent project has introduced a layer of abstraction to compiler errors. Previously, people would write down error messages directly in the same file the code was located to emit them. Now, there is a slug that connects the code in the compiler to the error message in the ftl file.

You can look at 7ef610c003f8072ec4ca4ecf195922a9a44e48dd to see an example of the changes:

Old:
```Rust
let msg = format!(
    "bounds on `{}` are most likely incorrect, consider instead \
        using `{}` to detect whether a type can be trivially dropped",
    predicate,
    cx.tcx.def_path_str(needs_drop)
);
lint.build(&msg).emit();
```
New (Rust side):
```Rust
lint.build(fluent::lint::drop_trait_constraints)
    .set_arg("predicate", predicate)
    .set_arg("needs_drop", cx.tcx.def_path_str(needs_drop))
    .emit();
```
New (Fluent side):
```fluent
lint-drop-trait-constraints =
    bounds on `{$predicate}` are most likely incorrect, consider instead using `{$needs_drop}` to detect whether a type can be trivially dropped
```

You will note that in the ftl file, the slug is slightly different from the slug in the Rust file: The ftl slug uses `-` (e.g. `lint-drop-trait-constraints`) while the rust slug uses `::` and `_` (e.g. `lint::drop_trait_constraints`). This choice was probably done due to:

* Rust not accepting `-` in identifiers (as it is an operator)
* fluent not supporting the `:` character in slug names (parse error upon attempts)
* all official fluent documentation using `-` instead of `_`

## The problem

The two different types of slugs, one with `-`, and one with `_`, cause difficulties for contributors. Imagine you don't have perfect knowledge of where stuff is in the compiler (i would say this is most people), and you encounter an error for which you think there is something you could improve that is not just a rewording.

So you want to find out where in the compiler's code that error is being emitted. The best way is via grepping.

1. you grep for the message in the compiler's source code. You discover the ftl file and find out the slug for that error.
2. That slug however contains `-` instead of `_`, so you have to manually translate the `-`'s into `_`s, and furthermore either remove the leading module name, or replace the first `-` with a `::`.
3. you do a second grep to get to the emitting location in the compiler's code.

This translation difficulty in step 2 appears also in the other direction when you want to figure out what some code in the compiler is doing and use error messages to help your understanding. Comments and variable names are way less exposed to users so [are more likely going to lie](https://github.com/rust-lang/rust/commit/cc3c5d2700481bae497d6cde825c1d48e79c776a) than error messages.

I think that at least the `-`→`_` translation which makes up most of step 2 can be removed at low cost.

## The solution

If you look closely, the practice of fluent to use `-` is only a stylistic choice and it is not enforced by fluent implementations, neither the playground nor the one the rust compiler uses, that slugs may not contain `_`. Thus, we can in fact migrate the ftl side to `_`. So now we'll have slugs like  `lint_drop_trait_constraints` on the ftl side. You only have to do one replacement now to get to the Rust slug: remove the first `_` and place a `::` in its stead. I would argue that this change is in fact useful as it allows you to control whether you want to look at the rust side of things or the ftl side of things via changing the query string only: with an increased number of translations checked into the repository, grepping for raw slugs will return the slug in many ftl files, so an explicit step to look for the source code is always useful. In the other direction (rust to fluent), you don't need a translation at all any more, as you can just take the final piece of the slug (e.g. `drop_trait_constraints`) and grep for that. The PR also adds enforcement to forbid usage of `_` in slug names. Internal slug names (those leading with a `-`) are exempt from that enforcement.

As another workflow that benefits from this change, people who add new errors don't have to do that `-` conversion either.

| Before/After | Fluent slug | Rust slug (no change) |
|--|--|--|
| Before | `lint-drop-trait-constraints` | `lint::drop_trait_constraints`|
| After | `lint_drop_trait_constraints` | `lint::drop_trait_constraints`|

Note that I've suggested this previously in the translation thread on zulip. I think it's important to think about non-translator contribution impact of fluent. I have certainly plans for more improvements, but this is a good first step.

``@rustbot`` label A-diagnostics

Rollup merge of #100325 - aDotInTheVoid:rdj-import-impl, r=GuillaumeGomez

Rustdoc-Json: Don't remove impls for items imported from private modules

After #99287, items in private modules may still be in the json output, if a public import accesses them. To reflect this, items that are imported need to be marked as retained in the `Stripper` pass, so their impls arn't removed by `ImplStripper`.

[More context on zulip](https://rust-lang.zulipchat.com/#narrow/stream/266220-rustdoc/topic/Populating.20cache.2Eimpls), thanks to @ jyn514 for helping debug this.

``@rustbot`` modify labels: +A-rustdoc-json +T-rustdoc

r? ``@GuillaumeGomez``

Fixes #100252
Fixes #100242

Rollup merge of #100031 - GoldsteinE:try-removing-the-field, r=michaelwoerister

improve "try ignoring the field" diagnostic

Closes #95795

rustdoc: Mark imported items as retained

Fixes a bug where impl of items that were imported from a private module
would be striped

Fixes #100252
Fixes #100242

Auto merge of #100569 - matthiaskrgr:rollup-9450lzs, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #100211 (Refuse to codegen an upstream static.)
 - #100277 (Simplify format_args builtin macro implementation.)
 - #100483 (Point to generic or arg if it's the self type of unsatisfied projection predicate)
 - #100506 (change `InlineAsmCtxt` to not talk about `FnCtxt`)
 - #100534 (Make code slightly more uniform)
 - #100566 (Use `create_snapshot_for_diagnostic` instead of `clone` for `Parser`)

Failed merges:

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

suggest adding an array length if possible

Add regression test for stripped enum variant fields

Handle correctly stripped enum variant fields

Revert "Revert "Remove num_cpus dependency from bootstrap, build-manifest and rustc_session""

This reverts commit 1ae4b258267462da0b1aae1badcf83578153c799.

Auto merge of #98393 - michaelwoerister:new-cpp-like-enum-debuginfo, r=wesleywiser

debuginfo: Generalize C++-like encoding for enums.

The updated encoding should be able to handle niche layouts where more than one variant has fields (as introduced in https://github.com/rust-lang/rust/pull/94075).

The new encoding is more uniform as there is no structural difference between direct-tag, niche-tag, and no-tag layouts anymore. The only difference between those cases is that the "dataful" variant in a niche-tag enum will have a `(start, end)` pair denoting the tag range instead of a single value.

The new encoding now also supports 128-bit tags, which occur in at least some standard library types. These tags are represented as `u64` pairs so that debuggers (which don't always have support for 128-bit integers) can reliably deal with them. The downside is that this adds quite a bit of complexity to the encoding and especially to the corresponding NatVis.

The new encoding seems to increase the size of (x86_64-pc-windows-msvc) debuginfo by 10-15%. The size of binaries is not affected (release builds were built with `-Cdebuginfo=2`, numbers are in kilobytes):

EXE | before | after | relative
-- | -- | -- | --
cargo (debug) | 40453 | 40450 | +0%
ripgrep (debug) | 10275 | 10273 | +0%
cargo (release) | 16186 | 16185 | +0%
ripgrep (release) | 4727 | 4726 | +0%

PDB | before | after | relative
-- | -- | -- | --
cargo (debug) | 236524 | 261412 | +11%
ripgrep (debug) | 53140 | 59060 | +11%
cargo (release) | 148516 | 169620 | +14%
ripgrep (release) | 10676 | 11804 | +11%

Given that the new encoding is more general, this is to be expected. Only platforms using C++-like debuginfo are affected -- which currently is only `*-pc-windows-msvc`.

*TODO*
- [x] Properly update documentation
- [x] Add regression tests for new optimized enum layouts as introduced by #94075.

r? `@wesleywiser`

[debuginfo] Fix msvc-pretty-enums debuginfo test for i686.

Rollup merge of #100566 - TaKO8Ki:use-create-snapshot-for-diagnostic, r=cjgillot

Use `create_snapshot_for_diagnostic` instead of `clone` for `Parser`

follow-up to #98020

Rollup merge of #100534 - Rageking8:Rageking8-refactor1, r=compiler-errors

Make code slightly more uniform

Rollup merge of #100506 - lcnr:fnctxt-yeet, r=compiler-errors

change `InlineAsmCtxt` to not talk about `FnCtxt`

wip for https://github.com/rust-lang/compiler-team/issues/529. this currently uses both the `FnCtxt` and is used by `check_mod_item_types`. This should be the only thing blocking that MCP afaict.

I am still unsure whether `rustc_hir_typeck` should depend on `rustc_hir_analysis` to use the `InlineAsmCtxt`. I think that's the best solution for now, so that's what I will go for

r? `@compiler-errors`

Rollup merge of #100483 - compiler-errors:point-to-projection-too, r=jyn514

Point to generic or arg if it's the self type of unsatisfied projection predicate

We do this for `TraitPredicate`s in `point_at_type_arg_instead_of_call_if_possible` and `point_at_arg_instead_of_call_if_possible`, so also do it for `ProjectionPredicate`.

Improves spans for a lot of unit tests.

Rollup merge of #100277 - m-ou-se:format-args-1, r=compiler-errors

Simplify format_args builtin macro implementation.

Instead of a FxHashMap<Symbol, (usize, Span)> for the named arguments, this now includes the name and span in the elements of the Vec<FormatArg> directly. The FxHashMap still exists to look up the index, but no longer contains the span. Looking up the name or span of an argument is now trivial and does not need the map anymore.

Rollup merge of #100211 - cjgillot:ctfe-mir-available, r=michaelwoerister

Refuse to codegen an upstream static.

Fixes https://github.com/rust-lang/rust/issues/85401

Add missing closing quote

fixes #100563

Fix STD build for ESP-IDF

use `create_snapshot_for_diagnostic` instead of `clone` for `Parser`

Auto merge of #96745 - ehuss:even-more-attribute-validation, r=cjgillot

Visit attributes in more places.

This adds 3 loosely related changes (I can split PRs if desired):

- Attribute checking on pattern struct fields.
- Attribute checking on struct expression fields.
- Lint level visiting on pattern struct fields, struct expression fields, and generic parameters.

There are still some lints which ignore lint levels in various positions. This is a consequence of how the lints themselves are implemented. For example, lint levels on associated consts don't work with `unused_braces`.

Simplify attribute handling in `parse_bottom_expr`.

`Parser::parse_bottom_expr` currently constructs an empty `attrs` and
then passes it to a large number of other functions. This makes the code
harder to read than it should be, because it's not clear that many
`attrs` arguments are always empty.

This commit removes `attrs` and the passing, simplifying a lot of
functions. The commit also renames `Parser::mk_expr` (which takes an
`attrs` argument) as `mk_expr_with_attrs`, and introduces a new
`mk_expr` which creates an expression with no attributes, which is the
more common case.

Auto merge of #96350 - austinabell:skip_optimization, r=Mark-Simulacrum

fix(iter::skip): Optimize `next` and `nth` implementations of `Skip`

This avoids calling nth/next or nth/nth to first skip elements and then get the next one (unless necessary due to usize overflow).

Auto merge of #100510 - compiler-errors:as-a-treat, r=jackh726

make `TypeError` impl `Copy`

r? `@ghost`

Streamline `parse_path_start_expr`.

Let-chaining avoids some code duplication.

Auto merge of #100540 - matthiaskrgr:rollup-734hkpt, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #100249 (Fix HorizonOS regression in FileTimes)
 - #100253 (Recover from mutable variable declaration where `mut` is placed before `let`)
 - #100482 (Add Duration rounding change to release note)
 - #100523 ([rustdoc] remove Clean trait)
 - #100524 (Impl `Debug` for some structs of rustbuild)
 - #100526 (Add tests for the drop behavior of some control flow constructs)

Failed merges:

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

Update the minimum external LLVM to 13

Also do it for generics

Point to argument if it's self type of unsatisfied projection predicate

TypeError can be Copy

Rollup merge of #100526 - Nilstrieb:tests!, r=Mark-Simulacrum

Add tests for the drop behavior of some control flow constructs

In #100513 it was shown that the drop behaviour of let_chains is not correct currently. Since drop behaviour is something pretty subtle, this adds explicit tests for the drop behavior of `if`, `if let` and `match` to make sure that it does not regress in the future.

The `println!`s were left in to make debugging easier in case something goes wrong, but they are not required for the test.

Rollup merge of #100524 - ohno418:impl-debug-for-some-rustbuild-structs, r=Mark-Simulacrum

Impl `Debug` for some structs of rustbuild

A small patch to impl `Debug` for some structs of rustbuild to make debugging easier.

(I was trying to impl `Debug` for the `Config` struct, but found to have a bit more things to do. So gave up for now.)

Rollup merge of #100523 - GuillaumeGomez:remove-clean-impls, r=Dylan-DPC

[rustdoc] remove Clean trait

Follow-up of https://github.com/rust-lang/rust/pull/99638.

This is (finally!) the last part.

r? `@Dylan-DPC`

Rollup merge of #100482 - youknowone:patch-1, r=Mark-Simulacrum

Add Duration rounding change to release note

one of possible fix of #100480

fixes https://github.com/rust-lang/rust/issues/100480

Rollup merge of #100253 - obeis:issue-100197, r=cjgillot

Recover from mutable variable declaration where `mut` is placed before `let`

Closes #100197

Rollup merge of #100249 - Meziu:master, r=joshtriplett

Fix HorizonOS regression in FileTimes

The changes in #98246 caused a regression for multiple Newlib-based systems. This is just a fix including HorizonOS to the list of  targets which require a workaround.

``@AzureMarker`` ``@ian-h-chamberlain``
r? ``@nagisa``

fix(iter::skip): Optimize `next` and `nth` implementations of `Skip`

Auto merge of #100429 - GuillaumeGomez:merge-html-elements-together, r=notriddle

rustdoc: Merge source code pages HTML elements together

We realized that the HTML generated for the source code pages could be improved quite a lot. This PR is a first pass toward this goal. Some explanations: it merges similar classes elements (even when there are white characters in between).

There is an exception to this: if this is an ident, I also merged it with "unclassified" elements. This part is up to debate and can be very easily removed as the check is performed in one place (in the `can_merge` function).

EDIT: The `ident` is now only kept in the code for the `span` it contains but it is not rendered into the HTML.

So now some numbers:

For these ones, on each page, I run this JS: `document.getElementsByTagName('*').length`. The goal is to count the number of DOM elements. I took some pages that seemed big, but don't hesitate to check some others.

| file name | before this PR | with this PR | diff | without ident | diff |
|-|-|-|-|-|-|
| std/lib.rs.html (source link on std crate page) | 3455 | 2776 | 20.7% | 2387 | 31% |
| alloc/vec/mod.rs.html (source on Vec type page) | 11012 | 8084 | 26.6% | 6682 | 39.4% |
| alloc/string.rs.html (source on String type page) | 10800 | 8214 | 24% | 6712 | 37.9% |
| std/sync/mutex.rs.html (source on Mutex type page) | 2953 | 2403 | 18.7% | 2139 | 27.6% |

You can test it [here](https://rustdoc.crud.net/imperio/merge-html-elements-together/src/std/lib.rs.html).

cc `@jsha`
r? `@notriddle`

Make code slightly more uniform

Add tests for the drop behavior of some control flow constructs

In #100513 it was shown that the drop behavior of let_chains is not correct
currently. Since drop behavior is something pretty subtle, this adds
explicit tests for the drop behavior of `if`, `if let` and `match` to
make sure that it does not regress in the future.

The `println!`s were left in to make debugging easier in case something
goes wrong, but they are not required for the test.

Auto merge of #100525 - Dylan-DPC:rollup-4cp6nu0, r=Dylan-DPC

Rollup of 6 pull requests

Successful merges:

 - #99582 (Delay a span bug if we see ty/const generic params during writeback)
 - #99861 (orphan check: rationalize our handling of constants)
 - #100026 (Add `Iterator::array_chunks` (take N+1))
 - #100115 (Suggest removing `let` if `const let` or `let const` is used)
 - #100126 (rustc_target: Update some old naming around self contained linking)
 - #100487 (`assert_{inhabited,zero_valid,uninit_valid}` intrinsics are safe)

Failed merges:

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

Rollup merge of #100487 - tmiasko:assert-safe, r=petrochenkov

`assert_{inhabited,zero_valid,uninit_valid}` intrinsics are safe

Those intrinsics either panic or do nothing. They are safe.

Rollup merge of #100126 - petrochenkov:screname, r=davidtwco

rustc_target: Update some old naming around self contained linking

The "fallback" naming pre-dates introduction of `-Clink-self-contained`.
Noticed when reviewing https://github.com/rust-lang/rust/pull/99500.

This PR doesn't break any json target spec, but supporting per-linker-flavor startup objects needed by https://github.com/rust-lang/rust/pull/99500 will break them, so maybe next time I'll remove the compatibility names.

Rollup merge of #100115 - obeis:issue-99910, r=cjgillot

Suggest removing `let` if `const let` or `let const` is used

Closes #99910

Rollup merge of #100026 - WaffleLapkin:array-chunks, r=scottmcm

Add `Iterator::array_chunks` (take N+1)

A revival of https://github.com/rust-lang/rust/pull/92393.

r? `@Mark-Simulacrum`
cc `@rossmacarthur` `@scottmcm` `@the8472`

I've tried to address most of the review comments on the previous attempt. The only thing I didn't address is `try_fold` implementation, I've left the "custom" one for now, not sure what exactly should it use.

Rollup merge of #99861 - lcnr:orphan-check-cg, r=jackh726

orphan check: rationalize our handling of constants

cc `@rust-lang/types` `@rust-lang/project-const-generics` on whether you agree with this reasoning.

r? types

Rollup merge of #99582 - compiler-errors:issue-99566, r=cjgillot

Delay a span bug if we see ty/const generic params during writeback

Fixes #99566

Update rustdoc tests

Impl Debug for some structs of rustbuild

feat: Target features for 1st group of RISC-V Bitmanip extensions

These use the same names as LLVM and is_riscv_feature_detected!:
- zba (address generation instructions)
- zbb (basic bit manipulation)
- zbc (carry-less multiplication)
- zbs (single-bit manipulation)

Remove the Clean trait

remove Clean trait implementation for hir::Variant

Don't generate ident elements as DOM nodes

Merge HTML elements in highlighting when they can be merged together

Auto merge of #100516 - compiler-errors:rollup-fgrfeb3, r=compiler-errors

Rollup of 8 pull requests

Successful merges:

 - #99646 (Only point out a single function parameter if we have a single arg incompatibility)
 - #100299 (make `clean::Item::span` return `Option` instead of dummy span)
 - #100335 (Rustdoc-Json: Add `Path` type for traits.)
 - #100367 (Suggest the path separator when a dot is used on a trait)
 - #100431 (Enum variant ctor inherits the stability of the enum variant)
 - #100446 (Suggest removing a semicolon after impl/trait items)
 - #100468 (Use an extensionless `x` script for non-Windows)
 - #100479 (Argument type error improvements)

Failed merges:

 - #100483 (Point to generic or arg if it's the self type of unsatisfied projection predicate)

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

Rollup merge of #100479 - compiler-errors:argument-type-error-improvements, r=lcnr

Argument type error improvements

Motivated by this interesting code snippet:

```rust
#[derive(Copy, Clone)]
struct Wrapper<T>(T);

fn foo(_: fn(i32), _: Wrapper<i32>) {}

fn f(_: u32) {}

fn main() {
    let w = Wrapper::<isize>(1isize);
    foo(f, w);
}
```

Which currently errors like:
```
error[E0308]: arguments to this function are incorrect
  --> src/main.rs:10:5
   |
10 |     foo(f, w);
   |     ^^^ -  - expected `i32`, found `isize`
   |         |
   |         expected `i32`, found `u32`
   |
   = note: expected fn pointer `fn(i32)`
                 found fn item `fn(u32) {f}`
   = note: expected struct `Wrapper<i32>`
              found struct `Wrapper<isize>`
note: function defined here
  --> src/main.rs:4:4
   |
4  | fn foo(_: fn(i32), _: Wrapper<i32>) {}
   |    ^^^ ----------  ---------------
```

Specifically, that double `expected .. found ..` which is very difficult to correlate to the types in the arguments. Also, the fact that "expected `i32`, found `isize`" and the other argument mismatch label don't even really explain what's going on here.

After this PR:
```
error[E0308]: arguments to this function are incorrect
  --> $DIR/two-mismatch-notes.rs:10:5
   |
LL |     foo(f, w);
   |     ^^^
   |
note: expected fn pointer, found fn item
  --> $DIR/two-mismatch-notes.rs:10:9
   |
LL |     foo(f, w);
   |         ^
   = note: expected fn pointer `fn(i32)`
                 found fn item `fn(u32) {f}`
note: expected struct `Wrapper`, found a different struct `Wrapper`
  --> $DIR/two-mismatch-notes.rs:10:12
   |
LL |     foo(f, w);
   |            ^
   = note: expected struct `Wrapper<i32>`
              found struct `Wrapper<isize>`
note: function defined here
  --> $DIR/two-mismatch-notes.rs:4:4
   |
LL | fn foo(_: fn(i32), _: Wrapper<i32>) {}
   |    ^^^ ----------  ---------------

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
```

Yeah, it's a bit verbose, but much clearer IMO.

---

Open to discussions about how this could be further improved. Motivated by `@jyn514's` [tweet](https://mobile.twitter.com/joshuayn514/status/1558042020601634816) here.

Rollup merge of #100468 - cuviper:lazy-x, r=jyn514

Use an extensionless `x` script for non-Windows

#99992 added `x.sh` and `x.ps1`, but this broke my lazy `./xTAB` habit that used to get me to `./x.py`. If we rename `x.sh` to `x`, then I can adjust to `./xSPACE` for the same number of characters typed.

r? `@jyn514`

Rollup merge of #100446 - TaKO8Ki:suggest-removing-semicolon-after-impl-trait-items, r=compiler-errors

Suggest removing a semicolon after impl/trait items

fixes #99822

Rollup merge of #100431 - compiler-errors:enum-ctor-variant-stab, r=estebank

Enum variant ctor inherits the stability of the enum variant

Fixes #100399
Fixes #100420

Context #71481 for why enum variants don't need stability

Rollup merge of #100367 - fmease:fix-100365, r=compiler-errors

Suggest the path separator when a dot is used on a trait

Fixes #100365.

`@rustbot` label A-diagnostics
r? diagnostics

Rollup merge of #100335 - aDotInTheVoid:rdj-resolved-path, r=GuillaumeGomez

Rustdoc-Json: Add `Path` type for traits.

Avoids using `Type` for trait fields, as a trait must always be a path, and not any other kind of type.

``@rustbot`` modify labels: +A-rustdoc-json +T-rustdoc

Closes #100106

Rollup merge of #100299 - compiler-errors:issue-100283, r=notriddle

make `clean::Item::span` return `Option` instead of dummy span

Fixes #100283

Rollup merge of #99646 - compiler-errors:arg-mismatch-single-arg-label, r=estebank

Only point out a single function parameter if we have a single arg incompatibility

Fixes #99635

Auto merge of #100495 - RalfJung:miri, r=RalfJung

update Miri

Fixes https://github.com/rust-lang/rust/issues/100424

Auto merge of #100511 - compiler-errors:rollup-vrte4w5, r=compiler-errors

Rollup of 11 pull requests

Successful merges:

 - #100355 (rustdoc: Rename ``@has` FILE PATTERN` to ``@hasraw` FILE PATTERN`)
 - #100407 (avoid some int2ptr casts in thread_local_key tests)
 - #100434 (Fix HIR pretty printing of let else)
 - #100438 (Erase regions better in `promote_candidate`)
 - #100445 (adapt test for msan message change)
 - #100447 (Remove more Clean trait implementations)
 - #100464 (Make `[rust] use-lld=true` work on windows)
 - #100475 (Give a helpful diagnostic when the next struct field has an attribute)
 - #100490 (wf: correctly `shallow_resolve` consts)
 - #100501 (nicer Miri backtraces for from_exposed_addr)
 - #100509 (merge two test directories that mean the same thing)

Failed merges:

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

Delay span bug when failing to normalize negative coherence impl subject due to other malformed impls

make clean::Item::span return option instead of dummy span

Rollup merge of #100509 - BoxyUwU:merge_hrtb_with_higher_rank_trait_bound, r=compiler-errors

merge two test directories that mean the same thing

hopefully `hrtb` doesnt have a secret second meaning that i'm not aware of :laughing:

r? `@compiler-errors`

Rollup merge of #100501 - RalfJung:miri-from-exposed-addr, r=Mark-Simulacrum

nicer Miri backtraces for from_exposed_addr

Miri by default warns about using from_exposed_addr; this makes the span for that a bit nicer.

Rollup merge of #100490 - lcnr:wf-consts, r=jackh726

wf: correctly `shallow_resolve` consts

`shallow_resolve` on `InferConst` is always a noop. this is mostly irrelevant as inference vars should already be resolved at most - if not all - call sites. Haven't actually looked too deeply into whether this was a problem.

Rollup merge of #100475 - chenyukang:fix-100461, r=fee1-dead

Give a helpful diagnostic when the next struct field has an attribute

Fixes #100461

Rollup merge of #100464 - khyperia:lld-icf-on-windows, r=jyn514

Make `[rust] use-lld=true` work on windows

Before, it would fail with "error: ignoring unknown argument '-Wl,--icf=all'"

This option was introduced in https://github.com/rust-lang/rust/pull/99062 (well, technically https://github.com/rust-lang/rust/pull/99680)

See zulip thread: https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/rust-lld.3A.20error.3A.20ignoring.20unknown.20argument.20'-Wl.2C--icf.3Dall'

Rollup merge of #100447 - GuillaumeGomez:rm-clean-impl, r=Dylan-DPC

Remove more Clean trait implementations

Follow-up of https://github.com/rust-lang/rust/pull/99638.

r? ``@Dylan-DPC``

Rollup merge of #100445 - krasimirgg:llvm-16-msan, r=tmiasko

adapt test for msan message change

LLVM commit https://github.com/llvm/llvm-project/commit/057cabd997aeaef136e1e14f2ee645bd5bb197dd removed the function from the msan error message. This adapts our test accordingly.

Found via our experimental rust + llvm @ HEAD bot:
https://buildkite.com/llvm-project/rust-llvm-integrate-prototype/builds/12634#018289fe-b0bc-4bab-89b3-fb1d4e38f6db

Rollup merge of #100438 - compiler-errors:issue-100360, r=lcnr

Erase regions better in `promote_candidate`

Use `tcx.erase_regions` instead of manually walking through the substs.... this also makes the code slightly simpler :see_no_evil:

Fixes #100360
Fixes #89851

Rollup merge of #100434 - compiler-errors:issue-100373, r=cjgillot

Fix HIR pretty printing of let else

Fixes #100373
Fixes #99318
Fixes #99319

Rollup merge of #100407 - RalfJung:no-int2ptr, r=Mark-Simulacrum

avoid some int2ptr casts in thread_local_key tests

Rollup merge of #100355 - camelid:has2-rename, r=GuillaumeGomez

rustdoc: Rename `@has FILE PATTERN` to `@hasraw FILE PATTERN`

Fixes #100354.

fix span_extend_to_next_char docs

wf correctly shallow_resolve consts

move

Do not inline non-simple argument type errors into labels

Label argument coercion errors

change `InlineAsmCtxt` to not talk about `FnCtxt`