Merge from rustc

author: The Miri Conjob Bot <miri@cron.bot> 2023-07-26 06:32:12 +0000
committer: The Miri Conjob Bot <miri@cron.bot> 2023-07-26 06:32:12 +0000
commit: eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5 (patch)
tree: 6b2403d4192e4adc6e70a4990d7f2c866c0af884 /src
parent: c5b26cd3ea0d7b012f1a10395e0b2e01c06d0335 (diff)
parent: 7d773c3304731716cc54db3531ba54067ca55a4a (diff)
download: rust-eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5.tar.gz
rust-eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5.zip
105 files changed, 5449 insertions, 653 deletions
diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs
index f3d95b57a76..400b07b1882 100644
--- a/src/bootstrap/compile.rs
+++ b/src/bootstrap/compile.rs
@@ -261,7 +261,7 @@ fn copy_self_contained_objects(
     // to using gcc from a glibc-targeting toolchain for linking.
     // To do that we have to distribute musl startup objects as a part of Rust toolchain
     // and link with them manually in the self-contained mode.
-    if target.contains("musl") {
+    if target.contains("musl") && !target.contains("unikraft") {
         let srcdir = builder.musl_libdir(target).unwrap_or_else(|| {
             panic!("Target {:?} does not have a \"musl-libdir\" key", target.triple)
         });
diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs
index 8c71b7f7fc2..c8750c19388 100644
--- a/src/bootstrap/dist.rs
+++ b/src/bootstrap/dist.rs
@@ -1085,13 +1085,6 @@ impl Step for Cargo {
         tarball.add_dir(etc.join("man"), "share/man/man1");
         tarball.add_legal_and_readme_to("share/doc/cargo");
 
-        for dirent in fs::read_dir(cargo.parent().unwrap()).expect("read_dir") {
-            let dirent = dirent.expect("read dir entry");
-            if dirent.file_name().to_str().expect("utf8").starts_with("cargo-credential-") {
-                tarball.add_file(&dirent.path(), "libexec", 0o755);
-            }
-        }
-
         Some(tarball.generate())
     }
 }
diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs
index e58f736d67f..2ccbf179cca 100644
--- a/src/bootstrap/doc.rs
+++ b/src/bootstrap/doc.rs
@@ -16,7 +16,7 @@ use crate::cache::{Interned, INTERNER};
 use crate::compile;
 use crate::config::{Config, TargetSelection};
 use crate::tool::{self, prepare_tool_cargo, SourceType, Tool};
-use crate::util::{symlink_dir, t, up_to_date};
+use crate::util::{dir_is_empty, symlink_dir, t, up_to_date};
 use crate::Mode;
 
 macro_rules! submodule_helper {
@@ -197,11 +197,21 @@ impl Step for TheBook {
         let compiler = self.compiler;
         let target = self.target;
 
+        let absolute_path = builder.src.join(&relative_path);
+        let redirect_path = absolute_path.join("redirects");
+        if !absolute_path.exists()
+            || !redirect_path.exists()
+            || dir_is_empty(&absolute_path)
+            || dir_is_empty(&redirect_path)
+        {
+            eprintln!("Please checkout submodule: {}", relative_path.display());
+            crate::exit!(1);
+        }
         // build book
         builder.ensure(RustbookSrc {
             target,
             name: INTERNER.intern_str("book"),
-            src: INTERNER.intern_path(builder.src.join(&relative_path)),
+            src: INTERNER.intern_path(absolute_path.clone()),
             parent: Some(self),
         });
 
@@ -210,7 +220,7 @@ impl Step for TheBook {
             builder.ensure(RustbookSrc {
                 target,
                 name: INTERNER.intern_string(format!("book/{}", edition)),
-                src: INTERNER.intern_path(builder.src.join(&relative_path).join(edition)),
+                src: INTERNER.intern_path(absolute_path.join(edition)),
                 // There should only be one book that is marked as the parent for each target, so
                 // treat the other editions as not having a parent.
                 parent: Option::<Self>::None,
@@ -225,7 +235,7 @@ impl Step for TheBook {
 
         // build the redirect pages
         let _guard = builder.msg_doc(compiler, "book redirect pages", target);
-        for file in t!(fs::read_dir(builder.src.join(&relative_path).join("redirects"))) {
+        for file in t!(fs::read_dir(redirect_path)) {
             let file = t!(file);
             let path = file.path();
             let path = path.to_str().unwrap();
@@ -884,19 +894,10 @@ tool_doc!(
         "-p",
         "cargo-credential",
         "-p",
-        "cargo-credential-1password",
-        "-p",
         "mdman",
         // FIXME: this trips a license check in tidy.
         // "-p",
         // "resolver-tests",
-        // FIXME: we should probably document these, but they're different per-platform so we can't use `tool_doc`.
-        // "-p",
-        // "cargo-credential-gnome-secret",
-        // "-p",
-        // "cargo-credential-macos-keychain",
-        // "-p",
-        // "cargo-credential-wincred",
     ]
 );
 tool_doc!(Tidy, "tidy", "src/tools/tidy", rustc_tool = false, ["-p", "tidy"]);
diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
index 059eb9ffc7b..365deb8e155 100644
--- a/src/bootstrap/lib.rs
+++ b/src/bootstrap/lib.rs
@@ -36,7 +36,7 @@ use once_cell::sync::OnceCell;
 use crate::builder::Kind;
 use crate::config::{LlvmLibunwind, TargetSelection};
 use crate::util::{
-    exe, libdir, mtime, output, run, run_suppressed, symlink_dir, try_run_suppressed,
+    dir_is_empty, exe, libdir, mtime, output, run, run_suppressed, symlink_dir, try_run_suppressed,
 };
 
 mod bolt;
@@ -131,6 +131,8 @@ const EXTRA_CHECK_CFGS: &[(Option<Mode>, &'static str, Option<&[&'static str]>)]
     (Some(Mode::Std), "freebsd13", None),
     (Some(Mode::Std), "backtrace_in_libstd", None),
     /* Extra values not defined in the built-in targets yet, but used in std */
+    // #[cfg(bootstrap)]
+    (Some(Mode::Std), "target_vendor", Some(&["unikraft"])),
     (Some(Mode::Std), "target_env", Some(&["libnx"])),
     // (Some(Mode::Std), "target_os", Some(&[])),
     // #[cfg(bootstrap)] mips32r6, mips64r6
@@ -535,10 +537,6 @@ impl Build {
     ///
     /// `relative_path` should be relative to the root of the git repository, not an absolute path.
     pub(crate) fn update_submodule(&self, relative_path: &Path) {
-        fn dir_is_empty(dir: &Path) -> bool {
-            t!(std::fs::read_dir(dir)).next().is_none()
-        }
-
         if !self.config.submodules(&self.rust_info()) {
             return;
         }
diff --git a/src/bootstrap/sanity.rs b/src/bootstrap/sanity.rs
index 9321fc1bcb8..145ae6f44da 100644
--- a/src/bootstrap/sanity.rs
+++ b/src/bootstrap/sanity.rs
@@ -206,7 +206,7 @@ than building it.
         }
 
         // Make sure musl-root is valid
-        if target.contains("musl") {
+        if target.contains("musl") && !target.contains("unikraft") {
             // If this is a native target (host is also musl) and no musl-root is given,
             // fall back to the system toolchain in /usr before giving up
             if build.musl_root(*target).is_none() && build.config.build == *target {
diff --git a/src/bootstrap/tool.rs b/src/bootstrap/tool.rs
index 725f864b718..e6d27757ac6 100644
--- a/src/bootstrap/tool.rs
+++ b/src/bootstrap/tool.rs
@@ -558,39 +558,6 @@ impl Step for Cargo {
                 allow_features: "",
             })
             .expect("expected to build -- essential tool");
-
-        let build_cred = |name, path| {
-            // These credential helpers are currently experimental.
-            // Any build failures will be ignored.
-            let _ = builder.ensure(ToolBuild {
-                compiler: self.compiler,
-                target: self.target,
-                tool: name,
-                mode: Mode::ToolRustc,
-                path,
-                is_optional_tool: true,
-                source_type: SourceType::Submodule,
-                extra_features: Vec::new(),
-                allow_features: "",
-            });
-        };
-
-        if self.target.contains("windows") {
-            build_cred(
-                "cargo-credential-wincred",
-                "src/tools/cargo/credential/cargo-credential-wincred",
-            );
-        }
-        if self.target.contains("apple-darwin") {
-            build_cred(
-                "cargo-credential-macos-keychain",
-                "src/tools/cargo/credential/cargo-credential-macos-keychain",
-            );
-        }
-        build_cred(
-            "cargo-credential-1password",
-            "src/tools/cargo/credential/cargo-credential-1password",
-        );
         cargo_bin_path
     }
 }
diff --git a/src/bootstrap/util.rs b/src/bootstrap/util.rs
index 2725813aba3..84ed2985464 100644
--- a/src/bootstrap/util.rs
+++ b/src/bootstrap/util.rs
@@ -493,3 +493,7 @@ pub fn lld_flag_no_threads(is_windows: bool) -> &'static str {
     });
     if is_windows { windows } else { other }
 }
+
+pub fn dir_is_empty(dir: &Path) -> bool {
+    t!(std::fs::read_dir(dir)).next().is_none()
+}
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 96ee9a586de..f108831138d 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -42,6 +42,8 @@
     - [sparc-unknown-none-elf](./platform-support/sparc-unknown-none-elf.md)
     - [*-pc-windows-gnullvm](platform-support/pc-windows-gnullvm.md)
     - [\*-nto-qnx-\*](platform-support/nto-qnx.md)
+    - [*-unikraft-linux-musl](platform-support/unikraft-linux-musl.md)
+    - [*-unknown-hermit](platform-support/hermit.md)
     - [\*-unknown-netbsd\*](platform-support/netbsd.md)
     - [*-unknown-openbsd](platform-support/openbsd.md)
     - [\*-unknown-uefi](platform-support/unknown-uefi.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 351b03b9337..8c5dc11eeef 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -223,7 +223,7 @@ target | std | host | notes
 [`aarch64-unknown-linux-ohos`](platform-support/openharmony.md) | ✓ |  | ARM64 OpenHarmony |
 [`aarch64-unknown-nto-qnx710`](platform-support/nto-qnx.md) | ✓ |  | ARM64 QNX Neutrino 7.1 RTOS |
 `aarch64-unknown-freebsd` | ✓ | ✓ | ARM64 FreeBSD
-`aarch64-unknown-hermit` | ✓ |  | ARM64 HermitCore
+[`aarch64-unknown-hermit`](platform-support/hermit.md) | ✓ |  | ARM64 Hermit
 `aarch64-unknown-linux-gnu_ilp32` | ✓ | ✓ | ARM64 Linux (ILP32 ABI)
 [`aarch64-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | ARM64 NetBSD
 [`aarch64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | ARM64 OpenBSD
@@ -303,6 +303,7 @@ target | std | host | notes
 [`riscv32imac-unknown-xous-elf`](platform-support/riscv32imac-unknown-xous-elf.md) | ? |  | RISC-V Xous (RV32IMAC ISA)
 [`riscv32imc-esp-espidf`](platform-support/esp-idf.md) | ✓ |  | RISC-V ESP-IDF
 [`riscv32imac-esp-espidf`](platform-support/esp-idf.md) | ✓ |  | RISC-V ESP-IDF
+[`riscv64gc-unknown-hermit`](platform-support/hermit.md) | ✓ |   | RISC-V Hermit
 `riscv64gc-unknown-freebsd` |   |   | RISC-V FreeBSD
 `riscv64gc-unknown-fuchsia` |   |   | RISC-V Fuchsia
 `riscv64gc-unknown-linux-musl` |   |   | RISC-V Linux (kernel 4.20, musl 1.2.0)
@@ -325,9 +326,10 @@ target | std | host | notes
 [`x86_64-pc-windows-gnullvm`](platform-support/pc-windows-gnullvm.md) | ✓ | ✓ |
 `x86_64-pc-windows-msvc` | * |  | 64-bit Windows XP support
 `x86_64-sun-solaris` | ? |  | Deprecated target for 64-bit Solaris 10/11, illumos
+[`x86_64-unikraft-linux-musl`](platform-support/unikraft-linux-musl.md) | ✓ |   | 64-bit Unikraft with musl
 `x86_64-unknown-dragonfly` | ✓ | ✓ | 64-bit DragonFlyBSD
 `x86_64-unknown-haiku` | ✓ | ✓ | 64-bit Haiku
-`x86_64-unknown-hermit` | ✓ |  | HermitCore
+[`x86_64-unknown-hermit`](platform-support/hermit.md) | ✓ |  | x86_64 Hermit
 `x86_64-unknown-l4re-uclibc` | ? |  |
 [`x86_64-unknown-linux-ohos`](platform-support/openharmony.md) | ✓ |  | x86_64 OpenHarmony |
 [`x86_64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | 64-bit OpenBSD
diff --git a/src/doc/rustc/src/platform-support/hermit.md b/src/doc/rustc/src/platform-support/hermit.md
new file mode 100644
index 00000000000..146079e36f4
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/hermit.md
@@ -0,0 +1,75 @@
+# `*-unknown-hermit`
+
+**Tier: 3**
+
+The [Hermit] unikernel target allows compiling your applications into self-contained, specialized unikernel images that can be run in small virtual machines.
+
+[Hermit]: https://github.com/hermitcore
+
+Target triplets available so far:
+
+- `x86_64-unknown-hermit`
+- `aarch64-unknown-hermit`
+- `riscv64gc-unknown-hermit`
+
+## Target maintainers
+
+- Stefan Lankes ([@stlankes](https://github.com/stlankes))
+- Martin Kröning ([@mkroening](https://github.com/mkroening))
+
+## Requirements
+
+These targets only support cross-compilation.
+The targets do support std.
+
+When building binaries for this target, the Hermit unikernel is built from scratch.
+The application developer themselves specializes the target and sets corresponding expectations.
+
+The Hermit targets follow Linux's `extern "C"` calling convention.
+
+Hermit binaries have the ELF format.
+
+## Building the target
+
+You can build Rust with support for the targets by adding it to the `target` list in `config.toml`.
+To run the Hermit build scripts, you also have to enable your host target.
+The build scripts rely on `llvm-tools` and binaries are linked using `rust-lld`, so those have to be enabled as well.
+
+```toml
+[build]
+build-stage = 1
+target = [
+    "<HOST_TARGET>",
+    "x86_64-unknown-hermit",
+    "aarch64-unknown-hermit",
+    "riscv64gc-unknown-hermit",
+]
+
+[rust]
+lld = true
+llvm-tools = true
+```
+
+## Building Rust programs
+
+Rust does not yet ship pre-compiled artifacts for these targets.
+To compile for these targets, you will either need to build Rust with the targets enabled
+(see “Building the targets” above), or build your own copy of `core` by using `build-std` or similar.
+
+Building Rust programs can be done by following the tutorial in our starter application [rusty-demo].
+
+[rusty-demo]: https://github.com/hermitcore/rusty-demo
+
+## Testing
+
+The targets support running binaries in the form of self-contained unikernel images.
+These images can be chainloaded by Hermit's [loader] or hypervisor ([Uhyve]).
+QEMU can be used to boot Hermit binaries using the loader on any architecture.
+The targets do not support running the Rust test suite.
+
+[loader]: https://github.com/hermitcore/rusty-loader
+[Uhyve]: https://github.com/hermitcore/uhyve
+
+## Cross-compilation toolchains and C code
+
+The targets do not yet support C code and Rust code at the same time.
diff --git a/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md b/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
index efd58e8302f..f579b1fb8d4 100644
--- a/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
+++ b/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
@@ -17,13 +17,6 @@ Rust for bare-metal 32-bit SPARC V7 and V8 systems, e.g. the Gaisler LEON3.
 This target is cross-compiled. There is no support for `std`. There is no
 default allocator, but it's possible to use `alloc` by supplying an allocator.
 
-This allows the generated code to run in environments, such as kernels, which
-may need to avoid the use of such registers or which may have special
-considerations about the use of such registers (e.g. saving and restoring them
-to avoid breaking userspace code using the same registers). You can change code
-generation to use additional CPU features via the `-C target-feature=` codegen
-options to rustc, or via the `#[target_feature]` mechanism within Rust code.
-
 By default, code generated with this target should run on any `SPARC` hardware;
 enabling additional target features may raise this baseline.
 
@@ -46,20 +39,31 @@ list in `config.toml`:
 ```toml
 [build]
 build-stage = 1
-target = ["sparc-unknown-none-elf"]
+host = ["<target for your host>"]
+target = ["<target for your host>", "sparc-unknown-none-elf"]
 ```
 
+Replace `<target for your host>` with `x86_64-unknown-linux-gnu` or whatever
+else is appropriate for your host machine.
+
 ## Building Rust programs
 
-```text
+To build with this target, pass it to the `--target` argument, like:
+
+```console
 cargo build --target sparc-unknown-none-elf
 ```
 
 This target uses GCC as a linker, and so you will need an appropriate GCC
-compatible `sparc-unknown-none` toolchain.
+compatible `sparc-unknown-none` toolchain. The default linker binary is
+`sparc-elf-gcc`, but you can override this in your project configuration, as
+follows:
 
-The default linker name is `sparc-elf-gcc`, but you can override this in your
-project configuration.
+`.cargo/config.toml`:
+```toml
+[target.sparc-unknown-none-elf]
+linker = "sparc-custom-elf-gcc"
+```
 
 ## Testing
 
@@ -84,21 +88,41 @@ runner = "tsim-leon3"
 [build]
 target = ["sparc-unknown-none-elf"]
 rustflags = "-Ctarget-cpu=leon3"
+```
+
+With this configuration, running `cargo run` will compile your code for the
+SPARC V8 compatible Gaisler Leon3 processor and then start the `tsim-leon3`
+simulator. The `libcore` was pre-compiled as part of the `rustc` compilation
+process using the SPARC V7 baseline, but if you are using a nightly toolchain
+you can use the
+[`-Z build-std=core`](https://doc.rust-lang.org/cargo/reference/unstable.html#build-std)
+option to rebuild `libcore` from source. This may be useful if you want to
+compile it for SPARC V8 and take advantage of the extra instructions.
+
+`.cargo/config.toml`:
+```toml
+[target.sparc-unknown-none-elf]
+linker = "sparc-gaisler-elf-gcc"
+runner = "tsim-leon3"
+
+[build]
+target = ["sparc-unknown-none-elf"]
+rustflags = "-Ctarget-cpu=leon3"
 
 [unstable]
 build-std = ["core"]
 ```
 
-With this configuration, running `cargo run` will compile your code for the
-SPARC V8 compatible Gaisler Leon3 processor and then start the `tsim-leon3`
-simulator. Once the simulator is running, simply enter the command
-`run` to start the code executing in the simulator.
+Either way, once the simulator is running, simply enter the command `run` to
+start the code executing in the simulator.
 
 The default C toolchain libraries are linked in, so with the Gaisler [BCC2]
 toolchain, and using its default Leon3 BSP, you can use call the C `putchar`
-function and friends to output to the simulator console.
+function and friends to output to the simulator console. The default linker
+script is also appropriate for the Leon3 simulator, so no linker script is
+required.
 
-Here's a complete example:
+Here's a complete example using the above config file:
 
 ```rust,ignore (cannot-test-this-because-it-assumes-special-libc-functions)
 #![no_std]
diff --git a/src/doc/rustc/src/platform-support/unikraft-linux-musl.md b/src/doc/rustc/src/platform-support/unikraft-linux-musl.md
new file mode 100644
index 00000000000..90fa18b9857
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/unikraft-linux-musl.md
@@ -0,0 +1,67 @@
+# `*-unikraft-linux-musl`
+
+**Tier: 3**
+
+Targets for the [Unikraft] Unikernel Development Kit (with musl).
+
+[Unikraft]: https://unikraft.org/
+
+Target triplets available so far:
+
+- `x86_64-unikraft-linux-musl`
+
+## Target maintainers
+
+- Martin Kröning ([@mkroening](https://github.com/mkroening))
+
+## Requirements
+
+These targets only support cross-compilation.
+The targets do support std.
+
+Unikraft pretends to behave exactly like Linux.
+How much of that functionality is available depends on the individual unikernel configuration.
+For example, the basic Unikraft + musl config does not support `poll` or networking out of the box.
+That functionality requires enabling [`LIBPOSIX_EVENT`] or [lwIP] respectively.
+
+[`LIBPOSIX_EVENT`]: https://github.com/unikraft/unikraft/blob/RELEASE-0.13.1/lib/posix-event/Config.uk
+[lwIP]: https://github.com/unikraft/lib-lwip
+
+The Unikraft targets follow Linux's `extern "C"` calling convention.
+
+For these targets, `rustc` does not perform the final linking step.
+Instead, the Unikraft build system will produce the final Unikernel image for the selected platform (e.g., KVM, Linux user space, and Xen).
+
+## Building the targets
+
+You can build Rust with support for the targets by adding it to the `target` list in `config.toml`:
+
+```toml
+[build]
+build-stage = 1
+target = [ "x86_64-unikraft-linux-musl" ]
+```
+
+## Building Rust programs
+
+Rust does not yet ship pre-compiled artifacts for these targets.
+To compile for these targets, you will either need to build Rust with the targets enabled
+(see “Building the targets” above), or build your own copy of `core` by using `build-std` or similar.
+
+Linking requires a [KraftKit] shim.
+See [unikraft/kraftkit#612] for more information.
+
+[KraftKit]: https://github.com/unikraft/kraftkit
+[unikraft/kraftkit#612]: https://github.com/unikraft/kraftkit/issues/612
+
+## Testing
+
+The targets do support running binaries in the form of unikernel images.
+How the unikernel image is run depends on the specific platform (e.g., KVM, Linux user space, and Xen).
+The targets do not support running the Rust test suite.
+
+## Cross-compilation toolchains and C code
+
+The targets do support C code.
+To build compatible C code, you have to use the same compiler and flags as does the Unikraft build system for your specific configuration.
+The easiest way to achieve that, is to build the C code with the Unikraft build system when building your unikernel image.
diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs
index f5e02940c82..9d744237b57 100644
--- a/src/librustdoc/clean/blanket_impl.rs
+++ b/src/librustdoc/clean/blanket_impl.rs
@@ -121,7 +121,8 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
                             .tcx
                             .associated_items(impl_def_id)
                             .in_definition_order()
-                            .map(|x| clean_middle_assoc_item(x, cx))
+                            .filter(|item| !item.is_impl_trait_in_trait())
+                            .map(|item| clean_middle_assoc_item(item, cx))
                             .collect::<Vec<_>>(),
                         polarity: ty::ImplPolarity::Positive,
                         kind: ImplKind::Blanket(Box::new(clean_middle_ty(
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index cfd9875e1c8..89eaf561e6a 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -216,6 +216,7 @@ pub(crate) fn build_external_trait(cx: &mut DocContext<'_>, did: DefId) -> clean
         .tcx
         .associated_items(did)
         .in_definition_order()
+        .filter(|item| !item.is_impl_trait_in_trait())
         .map(|item| clean_middle_assoc_item(item, cx))
         .collect();
 
@@ -459,6 +460,7 @@ pub(crate) fn build_impl(
         None => (
             tcx.associated_items(did)
                 .in_definition_order()
+                .filter(|item| !item.is_impl_trait_in_trait())
                 .filter(|item| {
                     // If this is a trait impl, filter out associated items whose corresponding item
                     // in the associated trait is marked `doc(hidden)`.
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index d14953f1bb7..440874df14c 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2643,15 +2643,12 @@ fn clean_extern_crate<'tcx>(
         }
     }
 
-    // FIXME: using `from_def_id_and_kind` breaks `rustdoc/masked` for some reason
-    vec![Item {
-        name: Some(name),
-        attrs: Box::new(Attributes::from_ast(attrs)),
-        item_id: crate_def_id.into(),
-        kind: Box::new(ExternCrateItem { src: orig_name }),
-        cfg: attrs.cfg(cx.tcx, &cx.cache.hidden_cfg),
-        inline_stmt_id: Some(krate_owner_def_id),
-    }]
+    vec![Item::from_def_id_and_parts(
+        krate_owner_def_id,
+        Some(name),
+        ExternCrateItem { src: orig_name },
+        cx,
+    )]
 }
 
 fn clean_use_statement<'tcx>(
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index df9da9e7c7f..5c8db3b8774 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -38,11 +38,15 @@ pub(crate) fn krate(cx: &mut DocContext<'_>) -> Crate {
             for it in &module.items {
                 // `compiler_builtins` should be masked too, but we can't apply
                 // `#[doc(masked)]` to the injected `extern crate` because it's unstable.
-                if it.is_extern_crate()
-                    && (it.attrs.has_doc_flag(sym::masked)
-                        || cx.tcx.is_compiler_builtins(it.item_id.krate()))
-                {
+                if cx.tcx.is_compiler_builtins(it.item_id.krate()) {
                     cx.cache.masked_crates.insert(it.item_id.krate());
+                } else if it.is_extern_crate()
+                    && it.attrs.has_doc_flag(sym::masked)
+                    && let Some(def_id) = it.item_id.as_def_id()
+                    && let Some(local_def_id) = def_id.as_local()
+                    && let Some(cnum) = cx.tcx.extern_mod_stmt_cnum(local_def_id)
+                {
+                    cx.cache.masked_crates.insert(cnum);
                 }
             }
         }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 1099c68b004..f60f40267d6 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -18,7 +18,7 @@ use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_metadata::creader::{CStore, LoadedMacro};
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
@@ -662,6 +662,14 @@ pub(crate) fn href_with_root_path(
             // documented on their parent's page
             tcx.parent(did)
         }
+        DefKind::ExternCrate => {
+            // Link to the crate itself, not the `extern crate` item.
+            if let Some(local_did) = did.as_local() {
+                tcx.extern_mod_stmt_cnum(local_did).unwrap_or(LOCAL_CRATE).as_def_id()
+            } else {
+                did
+            }
+        }
         _ => did,
     };
     let cache = cx.cache();
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 4d029407afa..2fcf61d0049 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1678,11 +1678,11 @@ fn render_impl(
         rendering_params: ImplRenderingParameters,
     ) {
         for trait_item in &t.items {
-            // Skip over any default trait items that are impossible to call
+            // Skip over any default trait items that are impossible to reference
             // (e.g. if it has a `Self: Sized` bound on an unsized type).
             if let Some(impl_def_id) = parent.item_id.as_def_id()
                 && let Some(trait_item_def_id) = trait_item.item_id.as_def_id()
-                && cx.tcx().is_impossible_method((impl_def_id, trait_item_def_id))
+                && cx.tcx().is_impossible_associated_item((impl_def_id, trait_item_def_id))
             {
                 continue;
             }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 91f3729bfa2..4de30e4ed9d 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -14,7 +14,7 @@ use rustc_hir::def::{DefKind, Namespace, PerNS};
 use rustc_hir::def_id::{DefId, CRATE_DEF_ID};
 use rustc_hir::Mutability;
 use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, ty};
+use rustc_middle::{bug, span_bug, ty};
 use rustc_resolve::rustdoc::{has_primitive_or_keyword_docs, prepare_to_doc_link_resolution};
 use rustc_resolve::rustdoc::{strip_generics_from_path, MalformedGenerics};
 use rustc_session::lint::Lint;
@@ -402,7 +402,12 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> {
             // `doc_link_resolutions` is missing a `path_str`, that means that there are valid links
             // that are being missed. To fix the ICE, change
             // `rustc_resolve::rustdoc::attrs_to_preprocessed_links` to cache the link.
-            .unwrap_or_else(|| panic!("no resolution for {:?} {:?} {:?}", path_str, ns, module_id))
+            .unwrap_or_else(|| {
+                span_bug!(
+                    self.cx.tcx.def_span(item_id),
+                    "no resolution for {path_str:?} {ns:?} {module_id:?}",
+                )
+            })
             .and_then(|res| res.try_into().ok())
             .or_else(|| resolve_primitive(path_str, ns));
         debug!("{} resolved to {:?} in namespace {:?}", path_str, result, ns);
@@ -963,6 +968,7 @@ fn preprocessed_markdown_links(s: &str) -> Vec<PreprocessedMarkdownLink> {
 }
 
 impl LinkCollector<'_, '_> {
+    #[instrument(level = "debug", skip_all)]
     fn resolve_links(&mut self, item: &Item) {
         if !self.cx.render_options.document_private
             && let Some(def_id) = item.item_id.as_def_id()
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 14618f89aed..a02ce68903d 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -122,6 +122,7 @@ static TARGETS: &[&str] = &[
     "riscv32imac-unknown-none-elf",
     "riscv32gc-unknown-linux-gnu",
     "riscv64imac-unknown-none-elf",
+    "riscv64gc-unknown-hermit",
     "riscv64gc-unknown-none-elf",
     "riscv64gc-unknown-linux-gnu",
     "s390x-unknown-linux-gnu",
@@ -147,6 +148,7 @@ static TARGETS: &[&str] = &[
     "x86_64-pc-windows-msvc",
     "x86_64-sun-solaris",
     "x86_64-pc-solaris",
+    "x86_64-unikraft-linux-musl",
     "x86_64-unknown-freebsd",
     "x86_64-unknown-illumos",
     "x86_64-unknown-linux-gnu",
diff --git a/src/tools/build_helper/src/ci.rs b/src/tools/build_helper/src/ci.rs
index b70ea5ec113..a8505ec9596 100644
--- a/src/tools/build_helper/src/ci.rs
+++ b/src/tools/build_helper/src/ci.rs
@@ -36,25 +36,26 @@ impl CiEnv {
 }
 
 pub mod gha {
-    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Mutex;
 
-    static GROUP_ACTIVE: AtomicBool = AtomicBool::new(false);
+    static ACTIVE_GROUPS: Mutex<Vec<String>> = Mutex::new(Vec::new());
 
     /// All github actions log messages from this call to the Drop of the return value
-    /// will be grouped and hidden by default in logs. Note that nesting these does
-    /// not really work.
+    /// will be grouped and hidden by default in logs. Note that since github actions doesn't
+    /// support group nesting, any active group will be first finished when a subgroup is started,
+    /// and then re-started when the subgroup finishes.
     #[track_caller]
     pub fn group(name: impl std::fmt::Display) -> Group {
-        if std::env::var_os("GITHUB_ACTIONS").is_some() {
-            eprintln!("::group::{name}");
-        } else {
-            eprintln!("{name}")
+        let mut groups = ACTIVE_GROUPS.lock().unwrap();
+
+        // A group is currently active. End it first to avoid nesting.
+        if !groups.is_empty() {
+            end_group();
         }
-        // https://github.com/actions/toolkit/issues/1001
-        assert!(
-            !GROUP_ACTIVE.swap(true, Ordering::Relaxed),
-            "nested groups are not supported by GHA!"
-        );
+
+        let name = name.to_string();
+        start_group(&name);
+        groups.push(name);
         Group(())
     }
 
@@ -64,13 +65,36 @@ pub mod gha {
 
     impl Drop for Group {
         fn drop(&mut self) {
-            if std::env::var_os("GITHUB_ACTIONS").is_some() {
-                eprintln!("::endgroup::");
+            end_group();
+
+            let mut groups = ACTIVE_GROUPS.lock().unwrap();
+            // Remove the current group
+            groups.pop();
+
+            // If there was some previous group, restart it
+            if is_in_gha() {
+                if let Some(name) = groups.last() {
+                    start_group(format!("{name} (continued)"));
+                }
             }
-            assert!(
-                GROUP_ACTIVE.swap(false, Ordering::Relaxed),
-                "group dropped but no group active!"
-            );
         }
     }
+
+    fn start_group(name: impl std::fmt::Display) {
+        if is_in_gha() {
+            eprintln!("::group::{name}");
+        } else {
+            eprintln!("{name}")
+        }
+    }
+
+    fn end_group() {
+        if is_in_gha() {
+            eprintln!("::endgroup::");
+        }
+    }
+
+    fn is_in_gha() -> bool {
+        std::env::var_os("GITHUB_ACTIONS").is_some()
+    }
 }
diff --git a/src/tools/cargo b/src/tools/cargo
-Subproject 1b15556767f4b78a64e868eedf4073c423f02b9
+Subproject 7ac9416d82cd4fc5e707c9ec3574d22dff6466e
diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs
index 58724852b3c..4d45091f4b5 100644
--- a/src/tools/clippy/clippy_lints/src/strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strings.rs
@@ -328,7 +328,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                     {
                         // Don't lint. Byte strings produce `&[u8; N]` whereas `as_bytes()` produces
                         // `&[u8]`. This change would prevent matching with different sized slices.
-                    } else {
+                    } else if !callsite.starts_with("env!") {
                         span_lint_and_sugg(
                             cx,
                             STRING_LIT_AS_BYTES,
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 1c29d614fa3..e563e41ab2a 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -14,7 +14,7 @@ use rustc_middle::mir::{
     Body, CastKind, NonDivergingIntrinsic, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind,
     Terminator, TerminatorKind,
 };
-use rustc_middle::traits::{ImplSource, ObligationCause};
+use rustc_middle::traits::{ImplSource, ObligationCause, BuiltinImplSource};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, BoundConstness, GenericArgKind, TraitRef, Ty, TyCtxt};
 use rustc_semver::RustcVersion;
@@ -411,7 +411,7 @@ fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>
 
     if !matches!(
         impl_src,
-        ImplSource::Builtin(_) | ImplSource::Param(_, ty::BoundConstness::ConstIfConst)
+        ImplSource::Builtin(BuiltinImplSource::Misc, _) | ImplSource::Param(ty::BoundConstness::ConstIfConst, _)
     ) {
         return false;
     }
diff --git a/src/tools/clippy/tests/ui/self_assignment.rs b/src/tools/clippy/tests/ui/self_assignment.rs
index d6682cc63dc..a7f9fbaae7c 100644
--- a/src/tools/clippy/tests/ui/self_assignment.rs
+++ b/src/tools/clippy/tests/ui/self_assignment.rs
@@ -14,7 +14,7 @@ pub fn positives(mut a: usize, b: &mut u32, mut s: S) {
     *b = *b;
     s = s;
     s.a = s.a;
-    s.b[10] = s.b[5 + 5];
+    s.b[9] = s.b[5 + 4];
     s.c[0][1] = s.c[0][1];
     s.b[a] = s.b[a];
     *s.e = *s.e;
diff --git a/src/tools/clippy/tests/ui/self_assignment.stderr b/src/tools/clippy/tests/ui/self_assignment.stderr
index bed88244eea..25b8569fa3d 100644
--- a/src/tools/clippy/tests/ui/self_assignment.stderr
+++ b/src/tools/clippy/tests/ui/self_assignment.stderr
@@ -24,11 +24,11 @@ error: self-assignment of `s.a` to `s.a`
 LL |     s.a = s.a;
    |     ^^^^^^^^^
 
-error: self-assignment of `s.b[5 + 5]` to `s.b[10]`
+error: self-assignment of `s.b[5 + 4]` to `s.b[9]`
   --> $DIR/self_assignment.rs:17:5
    |
-LL |     s.b[10] = s.b[5 + 5];
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |     s.b[9] = s.b[5 + 4];
+   |     ^^^^^^^^^^^^^^^^^^^
 
 error: self-assignment of `s.c[0][1]` to `s.c[0][1]`
   --> $DIR/self_assignment.rs:18:5
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index 4ae2249097f..269d9384376 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -6,7 +6,6 @@ use std::io::BufReader;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use build_helper::ci::CiEnv;
 use tracing::*;
 
 use crate::common::{Config, Debugger, FailMode, Mode, PassMode};
@@ -298,13 +297,6 @@ impl TestProps {
     /// `//[foo]`), then the property is ignored unless `cfg` is
     /// `Some("foo")`.
     fn load_from(&mut self, testfile: &Path, cfg: Option<&str>, config: &Config) {
-        // In CI, we've sometimes encountered non-determinism related to truncating very long paths.
-        // Set a consistent (short) prefix to avoid issues, but only in CI to avoid regressing the
-        // contributor experience.
-        if CiEnv::is_ci() {
-            self.remap_src_base = config.mode == Mode::Ui && !config.suite.contains("rustdoc");
-        }
-
         let mut has_edition = false;
         if !testfile.is_dir() {
             let file = File::open(testfile).unwrap();
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 7eeb987063f..ba068995d44 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2330,6 +2330,7 @@ impl<'test> TestCx<'test> {
                 // Hide line numbers to reduce churn
                 rustc.arg("-Zui-testing");
                 rustc.arg("-Zdeduplicate-diagnostics=no");
+                rustc.arg("-Zwrite-long-types-to-disk=no");
                 // FIXME: use this for other modes too, for perf?
                 rustc.arg("-Cstrip=debuginfo");
             }
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index 1aed436e88d..8059fddb100 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -928,13 +928,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 Ok(())
             }
         }
-        impl<'ecx, 'mir, 'tcx> MutValueVisitor<'mir, 'tcx, MiriMachine<'mir, 'tcx>>
+        impl<'ecx, 'mir, 'tcx> ValueVisitor<'mir, 'tcx, MiriMachine<'mir, 'tcx>>
             for RetagVisitor<'ecx, 'mir, 'tcx>
         {
             type V = PlaceTy<'tcx, Provenance>;
 
             #[inline(always)]
-            fn ecx(&mut self) -> &mut MiriInterpCx<'mir, 'tcx> {
+            fn ecx(&self) -> &MiriInterpCx<'mir, 'tcx> {
                 self.ecx
             }
 
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 2afd45829bd..9073f695442 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -413,13 +413,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 Ok(())
             }
         }
-        impl<'ecx, 'mir, 'tcx> MutValueVisitor<'mir, 'tcx, MiriMachine<'mir, 'tcx>>
+        impl<'ecx, 'mir, 'tcx> ValueVisitor<'mir, 'tcx, MiriMachine<'mir, 'tcx>>
             for RetagVisitor<'ecx, 'mir, 'tcx>
         {
             type V = PlaceTy<'tcx, Provenance>;
 
             #[inline(always)]
-            fn ecx(&mut self) -> &mut MiriInterpCx<'mir, 'tcx> {
+            fn ecx(&self) -> &MiriInterpCx<'mir, 'tcx> {
                 self.ecx
             }
 
@@ -578,14 +578,14 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 /// I.e. input is what you get from the visitor upon encountering an `adt` that is `Unique`,
 /// and output can be used by `retag_ptr_inplace`.
 fn inner_ptr_of_unique<'tcx>(
-    ecx: &mut MiriInterpCx<'_, 'tcx>,
+    ecx: &MiriInterpCx<'_, 'tcx>,
     place: &PlaceTy<'tcx, Provenance>,
 ) -> InterpResult<'tcx, PlaceTy<'tcx, Provenance>> {
     // Follows the same layout as `interpret/visitor.rs:walk_value` for `Box` in
     // `rustc_const_eval`, just with one fewer layer.
     // Here we have a `Unique(NonNull(*mut), PhantomData)`
     assert_eq!(place.layout.fields.count(), 2, "Unique must have exactly 2 fields");
-    let (nonnull, phantom) = (ecx.place_field(place, 0)?, ecx.place_field(place, 1)?);
+    let (nonnull, phantom) = (ecx.project_field(place, 0)?, ecx.project_field(place, 1)?);
     assert!(
         phantom.layout.ty.ty_adt_def().is_some_and(|adt| adt.is_phantom_data()),
         "2nd field of `Unique` should be `PhantomData` but is `{:?}`",
@@ -593,7 +593,7 @@ fn inner_ptr_of_unique<'tcx>(
     );
     // Now down to `NonNull(*mut)`
     assert_eq!(nonnull.layout.fields.count(), 1, "NonNull must have exactly 1 field");
-    let ptr = ecx.place_field(&nonnull, 0)?;
+    let ptr = ecx.project_field(&nonnull, 0)?;
     // Finally a plain `*mut`
     Ok(ptr)
 }
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 79a7115f24e..4f7b70649a9 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -320,7 +320,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
         ))?;
         let argvs_place = ecx.allocate(argvs_layout, MiriMemoryKind::Machine.into())?;
         for (idx, arg) in argvs.into_iter().enumerate() {
-            let place = ecx.mplace_field(&argvs_place, idx)?;
+            let place = ecx.project_field(&argvs_place, idx)?;
             ecx.write_immediate(arg, &place.into())?;
         }
         ecx.mark_immutable(&argvs_place);
@@ -354,7 +354,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
             ecx.machine.cmd_line = Some(*cmd_place);
             // Store the UTF-16 string. We just allocated so we know the bounds are fine.
             for (idx, &c) in cmd_utf16.iter().enumerate() {
-                let place = ecx.mplace_field(&cmd_place, idx)?;
+                let place = ecx.project_field(&cmd_place, idx)?;
                 ecx.write_scalar(Scalar::from_u16(c), &place.into())?;
             }
             ecx.mark_immutable(&cmd_place);
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index c19d691ede6..f6a438f5d62 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -10,6 +10,7 @@ use log::trace;
 
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc_index::IndexVec;
 use rustc_middle::mir;
 use rustc_middle::ty::{
     self,
@@ -17,7 +18,7 @@ use rustc_middle::ty::{
     List, TyCtxt,
 };
 use rustc_span::{def_id::CrateNum, sym, Span, Symbol};
-use rustc_target::abi::{Align, FieldsShape, Size, Variants};
+use rustc_target::abi::{Align, FieldIdx, FieldsShape, Size, Variants};
 use rustc_target::spec::abi::Abi;
 
 use rand::RngCore;
@@ -229,20 +230,20 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         this.layout_of(ty).unwrap()
     }
 
-    /// Project to the given *named* field of the mplace (which must be a struct or union type).
-    fn mplace_field_named(
+    /// Project to the given *named* field (which must be a struct or union type).
+    fn project_field_named<P: Projectable<'mir, 'tcx, Provenance>>(
         &self,
-        mplace: &MPlaceTy<'tcx, Provenance>,
+        base: &P,
         name: &str,
-    ) -> InterpResult<'tcx, MPlaceTy<'tcx, Provenance>> {
+    ) -> InterpResult<'tcx, P> {
         let this = self.eval_context_ref();
-        let adt = mplace.layout.ty.ty_adt_def().unwrap();
+        let adt = base.layout().ty.ty_adt_def().unwrap();
         for (idx, field) in adt.non_enum_variant().fields.iter().enumerate() {
             if field.name.as_str() == name {
-                return this.mplace_field(mplace, idx);
+                return this.project_field(base, idx);
             }
         }
-        bug!("No field named {} in type {}", name, mplace.layout.ty);
+        bug!("No field named {} in type {}", name, base.layout().ty);
     }
 
     /// Write an int of the appropriate size to `dest`. The target type may be signed or unsigned,
@@ -270,7 +271,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         for (idx, &val) in values.iter().enumerate() {
-            let field = this.mplace_field(dest, idx)?;
+            let field = this.project_field(dest, idx)?;
             this.write_int(val, &field.into())?;
         }
         Ok(())
@@ -284,7 +285,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         for &(name, val) in values.iter() {
-            let field = this.mplace_field_named(dest, name)?;
+            let field = this.project_field_named(dest, name)?;
             this.write_int(val, &field.into())?;
         }
         Ok(())
@@ -301,8 +302,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     }
 
     /// Get the `Place` for a local
-    fn local_place(&mut self, local: mir::Local) -> InterpResult<'tcx, PlaceTy<'tcx, Provenance>> {
-        let this = self.eval_context_mut();
+    fn local_place(&self, local: mir::Local) -> InterpResult<'tcx, PlaceTy<'tcx, Provenance>> {
+        let this = self.eval_context_ref();
         let place = mir::Place { local, projection: List::empty() };
         this.eval_place(place)
     }
@@ -479,6 +480,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 self.ecx
             }
 
+            fn aggregate_field_order(memory_index: &IndexVec<FieldIdx, u32>, idx: usize) -> usize {
+                // We need to do an *inverse* lookup: find the field that has position `idx` in memory order.
+                for (src_field, &mem_pos) in memory_index.iter_enumerated() {
+                    if mem_pos as usize == idx {
+                        return src_field.as_usize();
+                    }
+                }
+                panic!("invalid `memory_index`, could not find {}-th field in memory order", idx);
+            }
+
             // Hook to detect `UnsafeCell`.
             fn visit_value(&mut self, v: &MPlaceTy<'tcx, Provenance>) -> InterpResult<'tcx> {
                 trace!("UnsafeCellVisitor: {:?} {:?}", *v, v.layout.ty);
@@ -524,33 +535,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 }
             }
 
-            // Make sure we visit aggregates in increasing offset order.
-            fn visit_aggregate(
-                &mut self,
-                place: &MPlaceTy<'tcx, Provenance>,
-                fields: impl Iterator<Item = InterpResult<'tcx, MPlaceTy<'tcx, Provenance>>>,
-            ) -> InterpResult<'tcx> {
-                match place.layout.fields {
-                    FieldsShape::Array { .. } => {
-                        // For the array layout, we know the iterator will yield sorted elements so
-                        // we can avoid the allocation.
-                        self.walk_aggregate(place, fields)
-                    }
-                    FieldsShape::Arbitrary { .. } => {
-                        // Gather the subplaces and sort them before visiting.
-                        let mut places = fields
-                            .collect::<InterpResult<'tcx, Vec<MPlaceTy<'tcx, Provenance>>>>()?;
-                        // we just compare offsets, the abs. value never matters
-                        places.sort_by_key(|place| place.ptr.addr());
-                        self.walk_aggregate(place, places.into_iter().map(Ok))
-                    }
-                    FieldsShape::Union { .. } | FieldsShape::Primitive => {
-                        // Uh, what?
-                        bug!("unions/primitives are not aggregates we should ever visit")
-                    }
-                }
-            }
-
             fn visit_union(
                 &mut self,
                 _v: &MPlaceTy<'tcx, Provenance>,
@@ -746,7 +730,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         Ok(mplace)
     }
 
-    fn deref_pointer_as(
+    /// Deref' a pointer *without* checking that the place is dereferenceable.
+    fn deref_pointer_unchecked(
         &self,
         val: &ImmTy<'tcx, Provenance>,
         layout: TyAndLayout<'tcx>,
@@ -811,10 +796,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         tp: &MPlaceTy<'tcx, Provenance>,
     ) -> InterpResult<'tcx, Option<Duration>> {
         let this = self.eval_context_mut();
-        let seconds_place = this.mplace_field(tp, 0)?;
+        let seconds_place = this.project_field(tp, 0)?;
         let seconds_scalar = this.read_scalar(&seconds_place.into())?;
         let seconds = seconds_scalar.to_target_isize(this)?;
-        let nanoseconds_place = this.mplace_field(tp, 1)?;
+        let nanoseconds_place = this.project_field(tp, 1)?;
         let nanoseconds_scalar = this.read_scalar(&nanoseconds_place.into())?;
         let nanoseconds = nanoseconds_scalar.to_target_isize(this)?;
 
diff --git a/src/tools/miri/src/shims/backtrace.rs b/src/tools/miri/src/shims/backtrace.rs
index adf9a35d5c3..e4aa7467cbe 100644
--- a/src/tools/miri/src/shims/backtrace.rs
+++ b/src/tools/miri/src/shims/backtrace.rs
@@ -83,7 +83,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
                 // Write pointers into array
                 for (i, ptr) in ptrs.into_iter().enumerate() {
-                    let place = this.mplace_index(&alloc, i as u64)?;
+                    let place = this.project_index(&alloc, i as u64)?;
 
                     this.write_pointer(ptr, &place.into())?;
                 }
@@ -196,33 +196,33 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
                 this.write_immediate(
                     name_alloc.to_ref(this),
-                    &this.mplace_field(&dest, 0)?.into(),
+                    &this.project_field(&dest, 0)?.into(),
                 )?;
                 this.write_immediate(
                     filename_alloc.to_ref(this),
-                    &this.mplace_field(&dest, 1)?.into(),
+                    &this.project_field(&dest, 1)?.into(),
                 )?;
             }
             1 => {
                 this.write_scalar(
                     Scalar::from_target_usize(name.len().try_into().unwrap(), this),
-                    &this.mplace_field(&dest, 0)?.into(),
+                    &this.project_field(&dest, 0)?.into(),
                 )?;
                 this.write_scalar(
                     Scalar::from_target_usize(filename.len().try_into().unwrap(), this),
-                    &this.mplace_field(&dest, 1)?.into(),
+                    &this.project_field(&dest, 1)?.into(),
                 )?;
             }
             _ => throw_unsup_format!("unknown `miri_resolve_frame` flags {}", flags),
         }
 
-        this.write_scalar(Scalar::from_u32(lineno), &this.mplace_field(&dest, 2)?.into())?;
-        this.write_scalar(Scalar::from_u32(colno), &this.mplace_field(&dest, 3)?.into())?;
+        this.write_scalar(Scalar::from_u32(lineno), &this.project_field(&dest, 2)?.into())?;
+        this.write_scalar(Scalar::from_u32(colno), &this.project_field(&dest, 3)?.into())?;
 
         // Support a 4-field struct for now - this is deprecated
         // and slated for removal.
         if num_fields == 5 {
-            this.write_pointer(fn_ptr, &this.mplace_field(&dest, 4)?.into())?;
+            this.write_pointer(fn_ptr, &this.project_field(&dest, 4)?.into())?;
         }
 
         Ok(())
diff --git a/src/tools/miri/src/shims/env.rs b/src/tools/miri/src/shims/env.rs
index 1dcb877a83f..f98fd0431ae 100644
--- a/src/tools/miri/src/shims/env.rs
+++ b/src/tools/miri/src/shims/env.rs
@@ -456,7 +456,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         ))?;
         let vars_place = this.allocate(vars_layout, MiriMemoryKind::Runtime.into())?;
         for (idx, var) in vars.into_iter().enumerate() {
-            let place = this.mplace_field(&vars_place, idx)?;
+            let place = this.project_field(&vars_place, idx)?;
             this.write_pointer(var, &place.into())?;
         }
         this.write_pointer(vars_place.ptr, &this.machine.env_vars.environ.unwrap().into())?;
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 72a4adba8d4..c753eadbbad 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -942,9 +942,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 #[allow(clippy::arithmetic_side_effects)] // it's a u128, we can shift by 64
                 let (c_out, sum) = ((wide_sum >> 64).truncate::<u8>(), wide_sum.truncate::<u64>());
 
-                let c_out_field = this.place_field(dest, 0)?;
+                let c_out_field = this.project_field(dest, 0)?;
                 this.write_scalar(Scalar::from_u8(c_out), &c_out_field)?;
-                let sum_field = this.place_field(dest, 1)?;
+                let sum_field = this.project_field(dest, 1)?;
                 this.write_scalar(Scalar::from_u64(sum), &sum_field)?;
             }
             "llvm.x86.sse2.pause"
diff --git a/src/tools/miri/src/shims/intrinsics/simd.rs b/src/tools/miri/src/shims/intrinsics/simd.rs
index 94f8cfbfb1c..3afe5214f08 100644
--- a/src/tools/miri/src/shims/intrinsics/simd.rs
+++ b/src/tools/miri/src/shims/intrinsics/simd.rs
@@ -57,8 +57,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 };
 
                 for i in 0..dest_len {
-                    let op = this.read_immediate(&this.mplace_index(&op, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let op = this.read_immediate(&this.project_index(&op, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
                     let val = match which {
                         Op::MirOp(mir_op) => this.unary_op(mir_op, &op)?.to_scalar(),
                         Op::Abs => {
@@ -172,9 +172,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 };
 
                 for i in 0..dest_len {
-                    let left = this.read_immediate(&this.mplace_index(&left, i)?.into())?;
-                    let right = this.read_immediate(&this.mplace_index(&right, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let left = this.read_immediate(&this.project_index(&left, i)?.into())?;
+                    let right = this.read_immediate(&this.project_index(&right, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
                     let val = match which {
                         Op::MirOp(mir_op) => {
                             let (val, overflowed, ty) = this.overflowing_binary_op(mir_op, &left, &right)?;
@@ -232,10 +232,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 assert_eq!(dest_len, c_len);
 
                 for i in 0..dest_len {
-                    let a = this.read_scalar(&this.mplace_index(&a, i)?.into())?;
-                    let b = this.read_scalar(&this.mplace_index(&b, i)?.into())?;
-                    let c = this.read_scalar(&this.mplace_index(&c, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let a = this.read_scalar(&this.project_index(&a, i)?.into())?;
+                    let b = this.read_scalar(&this.project_index(&b, i)?.into())?;
+                    let c = this.read_scalar(&this.project_index(&c, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
 
                     // Works for f32 and f64.
                     // FIXME: using host floats to work around https://github.com/rust-lang/miri/issues/2468.
@@ -295,13 +295,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 };
 
                 // Initialize with first lane, then proceed with the rest.
-                let mut res = this.read_immediate(&this.mplace_index(&op, 0)?.into())?;
+                let mut res = this.read_immediate(&this.project_index(&op, 0)?.into())?;
                 if matches!(which, Op::MirOpBool(_)) {
                     // Convert to `bool` scalar.
                     res = imm_from_bool(simd_element_to_bool(res)?);
                 }
                 for i in 1..op_len {
-                    let op = this.read_immediate(&this.mplace_index(&op, i)?.into())?;
+                    let op = this.read_immediate(&this.project_index(&op, i)?.into())?;
                     res = match which {
                         Op::MirOp(mir_op) => {
                             this.binary_op(mir_op, &res, &op)?
@@ -355,7 +355,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
                 let mut res = init;
                 for i in 0..op_len {
-                    let op = this.read_immediate(&this.mplace_index(&op, i)?.into())?;
+                    let op = this.read_immediate(&this.project_index(&op, i)?.into())?;
                     res = this.binary_op(mir_op, &res, &op)?;
                 }
                 this.write_immediate(*res, dest)?;
@@ -372,10 +372,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 assert_eq!(dest_len, no_len);
 
                 for i in 0..dest_len {
-                    let mask = this.read_immediate(&this.mplace_index(&mask, i)?.into())?;
-                    let yes = this.read_immediate(&this.mplace_index(&yes, i)?.into())?;
-                    let no = this.read_immediate(&this.mplace_index(&no, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let mask = this.read_immediate(&this.project_index(&mask, i)?.into())?;
+                    let yes = this.read_immediate(&this.project_index(&yes, i)?.into())?;
+                    let no = this.read_immediate(&this.project_index(&no, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
 
                     let val = if simd_element_to_bool(mask)? { yes } else { no };
                     this.write_immediate(*val, &dest.into())?;
@@ -403,9 +403,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                         & 1u64
                             .checked_shl(simd_bitmask_index(i, dest_len, this.data_layout().endian))
                             .unwrap();
-                    let yes = this.read_immediate(&this.mplace_index(&yes, i.into())?.into())?;
-                    let no = this.read_immediate(&this.mplace_index(&no, i.into())?.into())?;
-                    let dest = this.mplace_index(&dest, i.into())?;
+                    let yes = this.read_immediate(&this.project_index(&yes, i.into())?.into())?;
+                    let no = this.read_immediate(&this.project_index(&no, i.into())?.into())?;
+                    let dest = this.project_index(&dest, i.into())?;
 
                     let val = if mask != 0 { yes } else { no };
                     this.write_immediate(*val, &dest.into())?;
@@ -435,8 +435,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 let from_exposed_cast = intrinsic_name == "from_exposed_addr";
 
                 for i in 0..dest_len {
-                    let op = this.read_immediate(&this.mplace_index(&op, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let op = this.read_immediate(&this.project_index(&op, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
 
                     let val = match (op.layout.ty.kind(), dest.layout.ty.kind()) {
                         // Int-to-(int|float): always safe
@@ -496,17 +496,17 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
                 for i in 0..dest_len {
                     let src_index: u64 = this
-                        .read_immediate(&this.operand_index(index, i)?)?
+                        .read_immediate(&this.project_index(index, i)?)?
                         .to_scalar()
                         .to_u32()?
                         .into();
-                    let dest = this.mplace_index(&dest, i)?;
+                    let dest = this.project_index(&dest, i)?;
 
                     let val = if src_index < left_len {
-                        this.read_immediate(&this.mplace_index(&left, src_index)?.into())?
+                        this.read_immediate(&this.project_index(&left, src_index)?.into())?
                     } else if src_index < left_len.checked_add(right_len).unwrap() {
                         let right_idx = src_index.checked_sub(left_len).unwrap();
-                        this.read_immediate(&this.mplace_index(&right, right_idx)?.into())?
+                        this.read_immediate(&this.project_index(&right, right_idx)?.into())?
                     } else {
                         span_bug!(
                             this.cur_span(),
@@ -528,10 +528,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 assert_eq!(dest_len, mask_len);
 
                 for i in 0..dest_len {
-                    let passthru = this.read_immediate(&this.mplace_index(&passthru, i)?.into())?;
-                    let ptr = this.read_immediate(&this.mplace_index(&ptrs, i)?.into())?;
-                    let mask = this.read_immediate(&this.mplace_index(&mask, i)?.into())?;
-                    let dest = this.mplace_index(&dest, i)?;
+                    let passthru = this.read_immediate(&this.project_index(&passthru, i)?.into())?;
+                    let ptr = this.read_immediate(&this.project_index(&ptrs, i)?.into())?;
+                    let mask = this.read_immediate(&this.project_index(&mask, i)?.into())?;
+                    let dest = this.project_index(&dest, i)?;
 
                     let val = if simd_element_to_bool(mask)? {
                         let place = this.deref_operand(&ptr.into())?;
@@ -552,9 +552,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 assert_eq!(ptrs_len, mask_len);
 
                 for i in 0..ptrs_len {
-                    let value = this.read_immediate(&this.mplace_index(&value, i)?.into())?;
-                    let ptr = this.read_immediate(&this.mplace_index(&ptrs, i)?.into())?;
-                    let mask = this.read_immediate(&this.mplace_index(&mask, i)?.into())?;
+                    let value = this.read_immediate(&this.project_index(&value, i)?.into())?;
+                    let ptr = this.read_immediate(&this.project_index(&ptrs, i)?.into())?;
+                    let mask = this.read_immediate(&this.project_index(&mask, i)?.into())?;
 
                     if simd_element_to_bool(mask)? {
                         let place = this.deref_operand(&ptr.into())?;
@@ -578,7 +578,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
                 let mut res = 0u64;
                 for i in 0..op_len {
-                    let op = this.read_immediate(&this.mplace_index(&op, i.into())?.into())?;
+                    let op = this.read_immediate(&this.project_index(&op, i.into())?.into())?;
                     if simd_element_to_bool(op)? {
                         res |= 1u64
                             .checked_shl(simd_bitmask_index(i, op_len, this.data_layout().endian))
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 4931f368857..14297845d3d 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -593,7 +593,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 #[allow(deprecated)]
                 let home_dir = std::env::home_dir().unwrap();
                 let (written, _) = this.write_path_to_c_str(&home_dir, buf, buflen)?;
-                let pw_dir = this.mplace_field_named(&pwd, "pw_dir")?;
+                let pw_dir = this.project_field_named(&pwd, "pw_dir")?;
                 this.write_pointer(buf, &pw_dir.into())?;
 
                 if written {
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 0fdd55b407c..3da6c17f3b0 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -1141,7 +1141,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 ("tv_sec", access_sec.into()),
                 ("tv_nsec", access_nsec.into()),
             ],
-            &this.mplace_field_named(&statxbuf, "stx_atime")?,
+            &this.project_field_named(&statxbuf, "stx_atime")?,
         )?;
         #[rustfmt::skip]
         this.write_int_fields_named(
@@ -1149,7 +1149,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 ("tv_sec", created_sec.into()),
                 ("tv_nsec", created_nsec.into()),
             ],
-            &this.mplace_field_named(&statxbuf, "stx_btime")?,
+            &this.project_field_named(&statxbuf, "stx_btime")?,
         )?;
         #[rustfmt::skip]
         this.write_int_fields_named(
@@ -1157,7 +1157,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 ("tv_sec", 0.into()),
                 ("tv_nsec", 0.into()),
             ],
-            &this.mplace_field_named(&statxbuf, "stx_ctime")?,
+            &this.project_field_named(&statxbuf, "stx_ctime")?,
         )?;
         #[rustfmt::skip]
         this.write_int_fields_named(
@@ -1165,7 +1165,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 ("tv_sec", modified_sec.into()),
                 ("tv_nsec", modified_nsec.into()),
             ],
-            &this.mplace_field_named(&statxbuf, "stx_mtime")?,
+            &this.project_field_named(&statxbuf, "stx_mtime")?,
         )?;
 
         Ok(0)
@@ -1421,7 +1421,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // }
 
                 let entry_place = this.deref_operand_as(entry_op, this.libc_ty_layout("dirent"))?;
-                let name_place = this.mplace_field(&entry_place, 5)?;
+                let name_place = this.project_field(&entry_place, 5)?;
 
                 let file_name = dir_entry.file_name(); // not a Path as there are no separators!
                 let (name_fits, file_name_buf_len) = this.write_os_str_to_c_str(
diff --git a/src/tools/miri/src/shims/unix/linux/fd.rs b/src/tools/miri/src/shims/unix/linux/fd.rs
index 87e887000c5..9c43651132b 100644
--- a/src/tools/miri/src/shims/unix/linux/fd.rs
+++ b/src/tools/miri/src/shims/unix/linux/fd.rs
@@ -73,9 +73,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         if op == epoll_ctl_add || op == epoll_ctl_mod {
             let event = this.deref_operand_as(event, this.libc_ty_layout("epoll_event"))?;
 
-            let events = this.mplace_field(&event, 0)?;
+            let events = this.project_field(&event, 0)?;
             let events = this.read_scalar(&events.into())?.to_u32()?;
-            let data = this.mplace_field(&event, 1)?;
+            let data = this.project_field(&event, 1)?;
             let data = this.read_scalar(&data.into())?;
             let event = EpollEvent { events, data };
 
diff --git a/src/tools/miri/src/shims/unix/linux/sync.rs b/src/tools/miri/src/shims/unix/linux/sync.rs
index 873b84e3059..0474c9fd90a 100644
--- a/src/tools/miri/src/shims/unix/linux/sync.rs
+++ b/src/tools/miri/src/shims/unix/linux/sync.rs
@@ -85,7 +85,8 @@ pub fn futex<'tcx>(
                 return Ok(());
             }
 
-            let timeout = this.deref_pointer_as(
+            // `read_timespec` will check the place when it is not null.
+            let timeout = this.deref_pointer_unchecked(
                 &this.read_immediate(&args[3])?,
                 this.libc_ty_layout("timespec"),
             )?;
diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
index 2888424c21e..d64aa53ed95 100644
--- a/src/tools/miri/src/shims/windows/foreign_items.rs
+++ b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -122,7 +122,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // We have to put the result into io_status_block.
                 if let Some(n) = written {
                     let io_status_information =
-                        this.mplace_field_named(&io_status_block, "Information")?;
+                        this.project_field_named(&io_status_block, "Information")?;
                     this.write_scalar(
                         Scalar::from_target_usize(n.into(), this),
                         &io_status_information.into(),
diff --git a/src/tools/miri/tests/pass/intrinsics.rs b/src/tools/miri/tests/pass/intrinsics.rs
index 6267e6e6bc1..a6a4a06f860 100644
--- a/src/tools/miri/tests/pass/intrinsics.rs
+++ b/src/tools/miri/tests/pass/intrinsics.rs
@@ -3,7 +3,7 @@
 //! Tests for various intrinsics that do not fit anywhere else.
 
 use std::intrinsics;
-use std::mem::{size_of, size_of_val, size_of_val_raw};
+use std::mem::{size_of, size_of_val, size_of_val_raw, discriminant};
 
 struct Bomb;
 
@@ -39,4 +39,7 @@ fn main() {
     let _v = intrinsics::discriminant_value(&0);
     let _v = intrinsics::discriminant_value(&true);
     let _v = intrinsics::discriminant_value(&vec![1, 2, 3]);
+    // Make sure that even if the discriminant is stored together with data, the intrinsic returns
+    // only the discriminant, nothing about the data.
+    assert_eq!(discriminant(&Some(false)), discriminant(&Some(true)));
 }
diff --git a/src/tools/rust-analyzer/.github/workflows/ci.yaml b/src/tools/rust-analyzer/.github/workflows/ci.yaml
index 31bb7eed8d7..9f246098e76 100644
--- a/src/tools/rust-analyzer/.github/workflows/ci.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/ci.yaml
@@ -161,10 +161,21 @@ jobs:
       #      if: runner.os == 'Linux'
       #      working-directory: ./editors/code
 
+      # If this steps fails, your code's type integrity might be wrong at some places at TypeScript level.
+      - run: npm run typecheck
+        working-directory: ./editors/code
+        if: needs.changes.outputs.typescript == 'true'
+
+      # You may fix the code automatically by running `npm run lint:fix` if this steps fails.
       - run: npm run lint
         working-directory: ./editors/code
         if: needs.changes.outputs.typescript == 'true'
 
+      # To fix this steps, please run `npm run format`.
+      - run: npm run format:check
+        working-directory: ./editors/code
+        if: needs.changes.outputs.typescript == 'true'
+
       - name: Run VS Code tests (Linux)
         if: matrix.os == 'ubuntu-latest' && needs.changes.outputs.typescript == 'true'
         env:
@@ -179,10 +190,6 @@ jobs:
         run: npm test
         working-directory: ./editors/code
 
-      - run: npm run pretest
-        working-directory: ./editors/code
-        if: needs.changes.outputs.typescript == 'true'
-
       - run: npm run package --scripts-prepend-node-path
         working-directory: ./editors/code
         if: needs.changes.outputs.typescript == 'true'
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/body/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/body/pretty.rs
index 0c6cf0b49a2..eeaed87164d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/body/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/body/pretty.rs
@@ -634,7 +634,7 @@ impl Printer<'_> {
         match literal {
             Literal::String(it) => w!(self, "{:?}", it),
             Literal::ByteString(it) => w!(self, "\"{}\"", it.escape_ascii()),
-            Literal::CString(it) => w!(self, "\"{}\\0\"", it),
+            Literal::CString(it) => w!(self, "\"{}\\0\"", it.escape_ascii()),
             Literal::Char(it) => w!(self, "'{}'", it.escape_debug()),
             Literal::Bool(it) => w!(self, "{}", it),
             Literal::Int(i, suffix) => {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
index 500e880061a..8a140a1ec18 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
@@ -85,7 +85,7 @@ impl fmt::Display for FloatTypeWrapper {
 pub enum Literal {
     String(Box<str>),
     ByteString(Box<[u8]>),
-    CString(Box<str>),
+    CString(Box<[u8]>),
     Char(char),
     Bool(bool),
     Int(i128, Option<BuiltinInt>),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 4de90d40a7c..1c0f7b08da8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -16,7 +16,8 @@ use triomphe::Arc;
 use crate::{
     db::HirDatabase, infer::InferenceContext, lower::ParamLoweringMode,
     mir::monomorphize_mir_body_bad, to_placeholder_idx, utils::Generics, Const, ConstData,
-    ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, Ty, TyBuilder,
+    ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, TraitEnvironment, Ty,
+    TyBuilder,
 };
 
 use super::mir::{interpret_mir, lower_to_mir, pad16, MirEvalError, MirLowerError};
@@ -135,7 +136,7 @@ pub fn intern_const_ref(
     ty: Ty,
     krate: CrateId,
 ) -> Const {
-    let layout = db.layout_of_ty(ty.clone(), krate);
+    let layout = db.layout_of_ty(ty.clone(), Arc::new(TraitEnvironment::empty(krate)));
     let bytes = match value {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
@@ -173,7 +174,7 @@ pub fn try_const_usize(db: &dyn HirDatabase, c: &Const) -> Option<u128> {
         chalk_ir::ConstValue::Concrete(c) => match &c.interned {
             ConstScalar::Bytes(it, _) => Some(u128::from_le_bytes(pad16(&it, false))),
             ConstScalar::UnevaluatedConst(c, subst) => {
-                let ec = db.const_eval(*c, subst.clone()).ok()?;
+                let ec = db.const_eval(*c, subst.clone(), None).ok()?;
                 try_const_usize(db, &ec)
             }
             _ => None,
@@ -186,6 +187,7 @@ pub(crate) fn const_eval_recover(
     _: &[String],
     _: &GeneralConstId,
     _: &Substitution,
+    _: &Option<Arc<TraitEnvironment>>,
 ) -> Result<Const, ConstEvalError> {
     Err(ConstEvalError::MirLowerError(MirLowerError::Loop))
 }
@@ -210,6 +212,7 @@ pub(crate) fn const_eval_query(
     db: &dyn HirDatabase,
     def: GeneralConstId,
     subst: Substitution,
+    trait_env: Option<Arc<TraitEnvironment>>,
 ) -> Result<Const, ConstEvalError> {
     let body = match def {
         GeneralConstId::ConstId(c) => {
@@ -228,7 +231,7 @@ pub(crate) fn const_eval_query(
         }
         GeneralConstId::InTypeConstId(c) => db.mir_body(c.into())?,
     };
-    let c = interpret_mir(db, body, false).0?;
+    let c = interpret_mir(db, body, false, trait_env).0?;
     Ok(c)
 }
 
@@ -241,7 +244,7 @@ pub(crate) fn const_eval_static_query(
         Substitution::empty(Interner),
         db.trait_environment_for_body(def.into()),
     )?;
-    let c = interpret_mir(db, body, false).0?;
+    let c = interpret_mir(db, body, false, None).0?;
     Ok(c)
 }
 
@@ -268,7 +271,7 @@ pub(crate) fn const_eval_discriminant_variant(
         Substitution::empty(Interner),
         db.trait_environment_for_body(def),
     )?;
-    let c = interpret_mir(db, mir_body, false).0?;
+    let c = interpret_mir(db, mir_body, false, None).0?;
     let c = try_const_usize(db, &c).unwrap() as i128;
     Ok(c)
 }
@@ -293,7 +296,7 @@ pub(crate) fn eval_to_const(
     }
     let infer = ctx.clone().resolve_all();
     if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, &ctx.body, &infer, expr) {
-        if let Ok(result) = interpret_mir(db, Arc::new(mir_body), true).0 {
+        if let Ok(result) = interpret_mir(db, Arc::new(mir_body), true, None).0 {
             return result;
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 5bb327606d3..98ebe557245 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -114,7 +114,7 @@ fn eval_goal(db: &TestDB, file_id: FileId) -> Result<Const, ConstEvalError> {
             _ => None,
         })
         .expect("No const named GOAL found in the test");
-    db.const_eval(const_id.into(), Substitution::empty(Interner))
+    db.const_eval(const_id.into(), Substitution::empty(Interner), None)
 }
 
 #[test]
@@ -1941,6 +1941,33 @@ fn dyn_trait() {
         "#,
         900,
     );
+    check_number(
+        r#"
+    //- minicore: coerce_unsized, index, slice
+    trait A {
+        fn x(&self) -> i32;
+    }
+
+    trait B: A {}
+
+    impl A for i32 {
+        fn x(&self) -> i32 {
+            5
+        }
+    }
+
+    impl B for i32 {
+
+    }
+
+    const fn f(x: &dyn B) -> i32 {
+        x.x()
+    }
+
+    const GOAL: i32 = f(&2i32);
+        "#,
+        5,
+    );
 }
 
 #[test]
@@ -2494,6 +2521,28 @@ fn const_trait_assoc() {
     );
     check_number(
         r#"
+    //- minicore: size_of
+    //- /a/lib.rs crate:a
+    use core::mem::size_of;
+    pub struct S<T>(T);
+    impl<T> S<T> {
+        pub const X: usize = core::mem::size_of::<T>();
+    }
+    //- /main.rs crate:main deps:a
+    use a::{S};
+    trait Tr {
+        type Ty;
+    }
+    impl Tr for i32 {
+        type Ty = u64;
+    }
+    struct K<T: Tr>(<T as Tr>::Ty);
+    const GOAL: usize = S::<K<i32>>::X;
+    "#,
+        8,
+    );
+    check_number(
+        r#"
     struct S<T>(*mut T);
 
     trait MySized: Sized {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 14b719ea412..9c96b5ab8db 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -77,8 +77,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
 
     #[salsa::invoke(crate::consteval::const_eval_query)]
     #[salsa::cycle(crate::consteval::const_eval_recover)]
-    fn const_eval(&self, def: GeneralConstId, subst: Substitution)
-        -> Result<Const, ConstEvalError>;
+    fn const_eval(
+        &self,
+        def: GeneralConstId,
+        subst: Substitution,
+        trait_env: Option<Arc<crate::TraitEnvironment>>,
+    ) -> Result<Const, ConstEvalError>;
 
     #[salsa::invoke(crate::consteval::const_eval_static_query)]
     #[salsa::cycle(crate::consteval::const_eval_static_recover)]
@@ -100,12 +104,16 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
         &self,
         def: AdtId,
         subst: Substitution,
-        krate: CrateId,
+        env: Arc<crate::TraitEnvironment>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
     #[salsa::cycle(crate::layout::layout_of_ty_recover)]
-    fn layout_of_ty(&self, ty: Ty, krate: CrateId) -> Result<Arc<Layout>, LayoutError>;
+    fn layout_of_ty(
+        &self,
+        ty: Ty,
+        env: Arc<crate::TraitEnvironment>,
+    ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::target_data_layout_query)]
     fn target_data_layout(&self, krate: CrateId) -> Option<Arc<TargetDataLayout>>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
index 73c8ad3dd5a..5aaa2bcc7c2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs
@@ -14,13 +14,12 @@ mod case_conv;
 
 use std::fmt;
 
-use base_db::CrateId;
 use hir_def::{
     data::adt::VariantData,
     hir::{Pat, PatId},
     src::HasSource,
-    AdtId, AttrDefId, ConstId, EnumId, FunctionId, ItemContainerId, Lookup, ModuleDefId, StaticId,
-    StructId,
+    AdtId, AttrDefId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, ItemContainerId,
+    Lookup, ModuleDefId, StaticId, StructId,
 };
 use hir_expand::{
     name::{AsName, Name},
@@ -44,13 +43,9 @@ mod allow {
     pub(super) const NON_CAMEL_CASE_TYPES: &str = "non_camel_case_types";
 }
 
-pub fn incorrect_case(
-    db: &dyn HirDatabase,
-    krate: CrateId,
-    owner: ModuleDefId,
-) -> Vec<IncorrectCase> {
+pub fn incorrect_case(db: &dyn HirDatabase, owner: ModuleDefId) -> Vec<IncorrectCase> {
     let _p = profile::span("validate_module_item");
-    let mut validator = DeclValidator::new(db, krate);
+    let mut validator = DeclValidator::new(db);
     validator.validate_item(owner);
     validator.sink
 }
@@ -120,7 +115,6 @@ pub struct IncorrectCase {
 
 pub(super) struct DeclValidator<'a> {
     db: &'a dyn HirDatabase,
-    krate: CrateId,
     pub(super) sink: Vec<IncorrectCase>,
 }
 
@@ -132,8 +126,8 @@ struct Replacement {
 }
 
 impl<'a> DeclValidator<'a> {
-    pub(super) fn new(db: &'a dyn HirDatabase, krate: CrateId) -> DeclValidator<'a> {
-        DeclValidator { db, krate, sink: Vec::new() }
+    pub(super) fn new(db: &'a dyn HirDatabase) -> DeclValidator<'a> {
+        DeclValidator { db, sink: Vec::new() }
     }
 
     pub(super) fn validate_item(&mut self, item: ModuleDefId) {
@@ -195,8 +189,7 @@ impl<'a> DeclValidator<'a> {
                 AttrDefId::TypeAliasId(_) => None,
                 AttrDefId::GenericParamId(_) => None,
             }
-            .map(|mid| self.allowed(mid, allow_name, true))
-            .unwrap_or(false)
+            .is_some_and(|mid| self.allowed(mid, allow_name, true))
     }
 
     fn validate_func(&mut self, func: FunctionId) {
@@ -206,17 +199,7 @@ impl<'a> DeclValidator<'a> {
             return;
         }
 
-        let body = self.db.body(func.into());
-
-        // Recursively validate inner scope items, such as static variables and constants.
-        for (_, block_def_map) in body.blocks(self.db.upcast()) {
-            for (_, module) in block_def_map.modules() {
-                for def_id in module.scope.declarations() {
-                    let mut validator = DeclValidator::new(self.db, self.krate);
-                    validator.validate_item(def_id);
-                }
-            }
-        }
+        self.validate_body_inner_items(func.into());
 
         // Check whether non-snake case identifiers are allowed for this function.
         if self.allowed(func.into(), allow::NON_SNAKE_CASE, false) {
@@ -231,6 +214,8 @@ impl<'a> DeclValidator<'a> {
             expected_case: CaseType::LowerSnakeCase,
         });
 
+        let body = self.db.body(func.into());
+
         // Check the patterns inside the function body.
         // This includes function parameters.
         let pats_replacements = body
@@ -496,6 +481,11 @@ impl<'a> DeclValidator<'a> {
     fn validate_enum(&mut self, enum_id: EnumId) {
         let data = self.db.enum_data(enum_id);
 
+        for (local_id, _) in data.variants.iter() {
+            let variant_id = EnumVariantId { parent: enum_id, local_id };
+            self.validate_body_inner_items(variant_id.into());
+        }
+
         // Check whether non-camel case names are allowed for this enum.
         if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES, false) {
             return;
@@ -512,13 +502,11 @@ impl<'a> DeclValidator<'a> {
         // Check the field names.
         let enum_fields_replacements = data
             .variants
-            .iter()
-            .filter_map(|(_, variant)| {
+            .values()
+            .filter_map(|variant| {
                 Some(Replacement {
                     current_name: variant.name.clone(),
-                    suggested_text: to_camel_case(
-                        &variant.name.display(self.db.upcast()).to_string(),
-                    )?,
+                    suggested_text: to_camel_case(&variant.name.to_smol_str())?,
                     expected_case: CaseType::UpperCamelCase,
                 })
             })
@@ -622,6 +610,8 @@ impl<'a> DeclValidator<'a> {
     fn validate_const(&mut self, const_id: ConstId) {
         let data = self.db.const_data(const_id);
 
+        self.validate_body_inner_items(const_id.into());
+
         if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
             return;
         }
@@ -631,7 +621,7 @@ impl<'a> DeclValidator<'a> {
             None => return,
         };
 
-        let const_name = name.display(self.db.upcast()).to_string();
+        let const_name = name.to_smol_str();
         let replacement = if let Some(new_name) = to_upper_snake_case(&const_name) {
             Replacement {
                 current_name: name.clone(),
@@ -670,13 +660,15 @@ impl<'a> DeclValidator<'a> {
             return;
         }
 
+        self.validate_body_inner_items(static_id.into());
+
         if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
             return;
         }
 
         let name = &data.name;
 
-        let static_name = name.display(self.db.upcast()).to_string();
+        let static_name = name.to_smol_str();
         let replacement = if let Some(new_name) = to_upper_snake_case(&static_name) {
             Replacement {
                 current_name: name.clone(),
@@ -707,4 +699,17 @@ impl<'a> DeclValidator<'a> {
 
         self.sink.push(diagnostic);
     }
+
+    // FIXME: We don't currently validate names within `DefWithBodyId::InTypeConstId`.
+    /// Recursively validates inner scope items, such as static variables and constants.
+    fn validate_body_inner_items(&mut self, body_id: DefWithBodyId) {
+        let body = self.db.body(body_id);
+        for (_, block_def_map) in body.blocks(self.db.upcast()) {
+            for (_, module) in block_def_map.modules() {
+                for def_id in module.scope.declarations() {
+                    self.validate_item(def_id);
+                }
+            }
+        }
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index 8cffdef289e..96787959e1f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -29,6 +29,7 @@ use itertools::Itertools;
 use la_arena::ArenaMap;
 use smallvec::SmallVec;
 use stdx::never;
+use triomphe::Arc;
 
 use crate::{
     consteval::try_const_usize,
@@ -43,7 +44,7 @@ use crate::{
     AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Const, ConstScalar, ConstValue,
     DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData, LifetimeOutlives,
     MemoryMap, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, Scalar,
-    Substitution, TraitRef, TraitRefExt, Ty, TyExt, WhereClause,
+    Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyExt, WhereClause,
 };
 
 pub trait HirWrite: fmt::Write {
@@ -454,7 +455,9 @@ fn render_const_scalar(
 ) -> Result<(), HirDisplayError> {
     // FIXME: We need to get krate from the final callers of the hir display
     // infrastructure and have it here as a field on `f`.
-    let krate = *f.db.crate_graph().crates_in_topological_order().last().unwrap();
+    let trait_env = Arc::new(TraitEnvironment::empty(
+        *f.db.crate_graph().crates_in_topological_order().last().unwrap(),
+    ));
     match ty.kind(Interner) {
         TyKind::Scalar(s) => match s {
             Scalar::Bool => write!(f, "{}", if b[0] == 0 { false } else { true }),
@@ -497,7 +500,7 @@ fn render_const_scalar(
             TyKind::Slice(ty) => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), krate) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size_one = layout.size.bytes_usize();
@@ -523,7 +526,7 @@ fn render_const_scalar(
                 let Ok(t) = memory_map.vtable.ty(ty_id) else {
                     return f.write_str("<ty-missing-in-vtable-map>");
                 };
-                let Ok(layout) = f.db.layout_of_ty(t.clone(), krate) else {
+                let Ok(layout) = f.db.layout_of_ty(t.clone(), trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -555,7 +558,7 @@ fn render_const_scalar(
                         return f.write_str("<layout-error>");
                     }
                 });
-                let Ok(layout) = f.db.layout_of_ty(t.clone(), krate) else {
+                let Ok(layout) = f.db.layout_of_ty(t.clone(), trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -567,7 +570,7 @@ fn render_const_scalar(
             }
         },
         TyKind::Tuple(_, subst) => {
-            let Ok(layout) = f.db.layout_of_ty(ty.clone(), krate) else {
+            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             f.write_str("(")?;
@@ -580,7 +583,7 @@ fn render_const_scalar(
                 }
                 let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
                 let offset = layout.fields.offset(id).bytes_usize();
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), krate) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
                     f.write_str("<layout-error>")?;
                     continue;
                 };
@@ -590,7 +593,7 @@ fn render_const_scalar(
             f.write_str(")")
         }
         TyKind::Adt(adt, subst) => {
-            let Ok(layout) = f.db.layout_of_adt(adt.0, subst.clone(), krate) else {
+            let Ok(layout) = f.db.layout_of_adt(adt.0, subst.clone(), trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             match adt.0 {
@@ -602,7 +605,7 @@ fn render_const_scalar(
                         &data.variant_data,
                         f,
                         &field_types,
-                        adt.0.module(f.db.upcast()).krate(),
+                        f.db.trait_environment(adt.0.into()),
                         &layout,
                         subst,
                         b,
@@ -614,7 +617,7 @@ fn render_const_scalar(
                 }
                 hir_def::AdtId::EnumId(e) => {
                     let Some((var_id, var_layout)) =
-                        detect_variant_from_bytes(&layout, f.db, krate, b, e)
+                        detect_variant_from_bytes(&layout, f.db, trait_env.clone(), b, e)
                     else {
                         return f.write_str("<failed-to-detect-variant>");
                     };
@@ -626,7 +629,7 @@ fn render_const_scalar(
                         &data.variant_data,
                         f,
                         &field_types,
-                        adt.0.module(f.db.upcast()).krate(),
+                        f.db.trait_environment(adt.0.into()),
                         &var_layout,
                         subst,
                         b,
@@ -645,7 +648,7 @@ fn render_const_scalar(
             let Some(len) = try_const_usize(f.db, len) else {
                 return f.write_str("<unknown-array-len>");
             };
-            let Ok(layout) = f.db.layout_of_ty(ty.clone(), krate) else {
+            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
                 return f.write_str("<layout-error>");
             };
             let size_one = layout.size.bytes_usize();
@@ -684,7 +687,7 @@ fn render_variant_after_name(
     data: &VariantData,
     f: &mut HirFormatter<'_>,
     field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,
-    krate: CrateId,
+    trait_env: Arc<TraitEnvironment>,
     layout: &Layout,
     subst: &Substitution,
     b: &[u8],
@@ -695,7 +698,7 @@ fn render_variant_after_name(
             let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {
                 let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();
                 let ty = field_types[id].clone().substitute(Interner, subst);
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), krate) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index 4b14345aa39..72e6443beb7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -1665,6 +1665,7 @@ impl InferenceContext<'_> {
                 // the parameter to coerce to the expected type (for example in
                 // `coerce_unsize_expected_type_4`).
                 let param_ty = self.normalize_associated_types_in(param_ty);
+                let expected_ty = self.normalize_associated_types_in(expected_ty);
                 let expected = Expectation::rvalue_hint(self, expected_ty);
                 // infer with the expected type we have...
                 let ty = self.infer_expr_inner(arg, &expected);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 385f39f5374..0fb71135b4d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -252,7 +252,8 @@ impl<'a> InferenceTable<'a> {
                             // and registering an obligation. But it needs chalk support, so we handle the most basic
                             // case (a non associated const without generic parameters) manually.
                             if subst.len(Interner) == 0 {
-                                if let Ok(eval) = self.db.const_eval((*c_id).into(), subst.clone())
+                                if let Ok(eval) =
+                                    self.db.const_eval((*c_id).into(), subst.clone(), None)
                                 {
                                     eval
                                 } else {
@@ -785,7 +786,7 @@ impl<'a> InferenceTable<'a> {
                 crate::ConstScalar::Unknown => self.new_const_var(data.ty.clone()),
                 // try to evaluate unevaluated const. Replace with new var if const eval failed.
                 crate::ConstScalar::UnevaluatedConst(id, subst) => {
-                    if let Ok(eval) = self.db.const_eval(*id, subst.clone()) {
+                    if let Ok(eval) = self.db.const_eval(*id, subst.clone(), None) {
                         eval
                     } else {
                         self.new_const_var(data.ty.clone())
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 72e2bcc5559..ffc7a6f2ebd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -1,6 +1,5 @@
 //! Compute the binary representation of a type
 
-use base_db::CrateId;
 use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy};
 use hir_def::{
     layout::{
@@ -61,7 +60,6 @@ pub enum LayoutError {
 }
 
 struct LayoutCx<'a> {
-    krate: CrateId,
     target: &'a TargetDataLayout,
 }
 
@@ -82,7 +80,7 @@ fn layout_of_simd_ty(
     db: &dyn HirDatabase,
     id: StructId,
     subst: &Substitution,
-    krate: CrateId,
+    env: Arc<TraitEnvironment>,
     dl: &TargetDataLayout,
 ) -> Result<Arc<Layout>, LayoutError> {
     let fields = db.field_types(id.into());
@@ -111,7 +109,7 @@ fn layout_of_simd_ty(
     // * the homogeneous field type and the number of fields.
     let (e_ty, e_len, is_array) = if let TyKind::Array(e_ty, _) = f0_ty.kind(Interner) {
         // Extract the number of elements from the layout of the array field:
-        let FieldsShape::Array { count, .. } = db.layout_of_ty(f0_ty.clone(), krate)?.fields else {
+        let FieldsShape::Array { count, .. } = db.layout_of_ty(f0_ty.clone(), env.clone())?.fields else {
             user_error!("Array with non array layout");
         };
 
@@ -122,7 +120,7 @@ fn layout_of_simd_ty(
     };
 
     // Compute the ABI of the element type:
-    let e_ly = db.layout_of_ty(e_ty, krate)?;
+    let e_ly = db.layout_of_ty(e_ty, env.clone())?;
     let Abi::Scalar(e_abi) = e_ly.abi else {
         user_error!("simd type with inner non scalar type");
     };
@@ -152,25 +150,25 @@ fn layout_of_simd_ty(
 pub fn layout_of_ty_query(
     db: &dyn HirDatabase,
     ty: Ty,
-    krate: CrateId,
+    trait_env: Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
+    let krate = trait_env.krate;
     let Some(target) = db.target_data_layout(krate) else {
         return Err(LayoutError::TargetLayoutNotAvailable);
     };
-    let cx = LayoutCx { krate, target: &target };
+    let cx = LayoutCx { target: &target };
     let dl = &*cx.current_data_layout();
-    let trait_env = Arc::new(TraitEnvironment::empty(krate));
-    let ty = normalize(db, trait_env, ty.clone());
+    let ty = normalize(db, trait_env.clone(), ty.clone());
     let result = match ty.kind(Interner) {
         TyKind::Adt(AdtId(def), subst) => {
             if let hir_def::AdtId::StructId(s) = def {
                 let data = db.struct_data(*s);
                 let repr = data.repr.unwrap_or_default();
                 if repr.simd() {
-                    return layout_of_simd_ty(db, *s, subst, krate, &target);
+                    return layout_of_simd_ty(db, *s, subst, trait_env.clone(), &target);
                 }
             };
-            return db.layout_of_adt(*def, subst.clone(), krate);
+            return db.layout_of_adt(*def, subst.clone(), trait_env.clone());
         }
         TyKind::Scalar(s) => match s {
             chalk_ir::Scalar::Bool => Layout::scalar(
@@ -228,7 +226,7 @@ pub fn layout_of_ty_query(
 
             let fields = tys
                 .iter(Interner)
-                .map(|k| db.layout_of_ty(k.assert_ty_ref(Interner).clone(), krate))
+                .map(|k| db.layout_of_ty(k.assert_ty_ref(Interner).clone(), trait_env.clone()))
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
             let fields = fields.iter().collect::<Vec<_>>();
@@ -238,7 +236,7 @@ pub fn layout_of_ty_query(
             let count = try_const_usize(db, &count).ok_or(LayoutError::UserError(
                 "unevaluated or mistyped const generic parameter".to_string(),
             ))? as u64;
-            let element = db.layout_of_ty(element.clone(), krate)?;
+            let element = db.layout_of_ty(element.clone(), trait_env.clone())?;
             let size = element.size.checked_mul(count, dl).ok_or(LayoutError::SizeOverflow)?;
 
             let abi = if count != 0 && matches!(element.abi, Abi::Uninhabited) {
@@ -259,7 +257,7 @@ pub fn layout_of_ty_query(
             }
         }
         TyKind::Slice(element) => {
-            let element = db.layout_of_ty(element.clone(), krate)?;
+            let element = db.layout_of_ty(element.clone(), trait_env.clone())?;
             Layout {
                 variants: Variants::Single { index: struct_variant_idx() },
                 fields: FieldsShape::Array { stride: element.size, count: 0 },
@@ -335,7 +333,7 @@ pub fn layout_of_ty_query(
             match impl_trait_id {
                 crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                     let infer = db.infer(func.into());
-                    return db.layout_of_ty(infer.type_of_rpit[idx].clone(), krate);
+                    return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env.clone());
                 }
                 crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
                     return Err(LayoutError::NotImplemented)
@@ -351,7 +349,7 @@ pub fn layout_of_ty_query(
                 .map(|it| {
                     db.layout_of_ty(
                         it.ty.clone().substitute(Interner, ClosureSubst(subst).parent_subst()),
-                        krate,
+                        trait_env.clone(),
                     )
                 })
                 .collect::<Result<Vec<_>, _>>()?;
@@ -377,7 +375,7 @@ pub fn layout_of_ty_recover(
     _: &dyn HirDatabase,
     _: &[String],
     _: &Ty,
-    _: &CrateId,
+    _: &Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
     user_error!("infinite sized recursive type");
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index 19d5e98e738..1c92e80f335 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -2,7 +2,6 @@
 
 use std::{cmp, ops::Bound};
 
-use base_db::CrateId;
 use hir_def::{
     data::adt::VariantData,
     layout::{Integer, LayoutCalculator, ReprOptions, TargetDataLayout},
@@ -16,7 +15,7 @@ use crate::{
     db::HirDatabase,
     lang_items::is_unsafe_cell,
     layout::{field_ty, Layout, LayoutError, RustcEnumVariantIdx},
-    Substitution,
+    Substitution, TraitEnvironment,
 };
 
 use super::LayoutCx;
@@ -29,17 +28,18 @@ pub fn layout_of_adt_query(
     db: &dyn HirDatabase,
     def: AdtId,
     subst: Substitution,
-    krate: CrateId,
+    trait_env: Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
+    let krate = trait_env.krate;
     let Some(target) = db.target_data_layout(krate) else {
         return Err(LayoutError::TargetLayoutNotAvailable);
     };
-    let cx = LayoutCx { krate, target: &target };
+    let cx = LayoutCx { target: &target };
     let dl = cx.current_data_layout();
     let handle_variant = |def: VariantId, var: &VariantData| {
         var.fields()
             .iter()
-            .map(|(fd, _)| db.layout_of_ty(field_ty(db, def, fd, &subst), cx.krate))
+            .map(|(fd, _)| db.layout_of_ty(field_ty(db, def, fd, &subst), trait_env.clone()))
             .collect::<Result<Vec<_>, _>>()
     };
     let (variants, repr) = match def {
@@ -134,7 +134,7 @@ pub fn layout_of_adt_recover(
     _: &[String],
     _: &AdtId,
     _: &Substitution,
-    _: &CrateId,
+    _: &Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
     user_error!("infinite sized recursive type");
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index a3ced2bac0a..333ad473a8b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -26,7 +26,7 @@ fn eval_goal(ra_fixture: &str, minicore: &str) -> Result<Arc<Layout>, LayoutErro
     );
 
     let (db, file_ids) = TestDB::with_many_files(&ra_fixture);
-    let (adt_or_type_alias_id, module_id) = file_ids
+    let adt_or_type_alias_id = file_ids
         .into_iter()
         .find_map(|file_id| {
             let module_id = db.module_for_file(file_id);
@@ -47,7 +47,7 @@ fn eval_goal(ra_fixture: &str, minicore: &str) -> Result<Arc<Layout>, LayoutErro
                 }
                 _ => None,
             })?;
-            Some((adt_or_type_alias_id, module_id))
+            Some(adt_or_type_alias_id)
         })
         .unwrap();
     let goal_ty = match adt_or_type_alias_id {
@@ -58,7 +58,13 @@ fn eval_goal(ra_fixture: &str, minicore: &str) -> Result<Arc<Layout>, LayoutErro
             db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))
         }
     };
-    db.layout_of_ty(goal_ty, module_id.krate())
+    db.layout_of_ty(
+        goal_ty,
+        db.trait_environment(match adt_or_type_alias_id {
+            Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
+            Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
+        }),
+    )
 }
 
 /// A version of `eval_goal` for types that can not be expressed in ADTs, like closures and `impl Trait`
@@ -72,7 +78,7 @@ fn eval_expr(ra_fixture: &str, minicore: &str) -> Result<Arc<Layout>, LayoutErro
     let module_id = db.module_for_file(file_id);
     let def_map = module_id.def_map(&db);
     let scope = &def_map[module_id.local_id].scope;
-    let adt_id = scope
+    let function_id = scope
         .declarations()
         .find_map(|x| match x {
             hir_def::ModuleDefId::FunctionId(x) => {
@@ -82,11 +88,11 @@ fn eval_expr(ra_fixture: &str, minicore: &str) -> Result<Arc<Layout>, LayoutErro
             _ => None,
         })
         .unwrap();
-    let hir_body = db.body(adt_id.into());
+    let hir_body = db.body(function_id.into());
     let b = hir_body.bindings.iter().find(|x| x.1.name.to_smol_str() == "goal").unwrap().0;
-    let infer = db.infer(adt_id.into());
+    let infer = db.infer(function_id.into());
     let goal_ty = infer.type_of_binding[b].clone();
-    db.layout_of_ty(goal_ty, module_id.krate())
+    db.layout_of_ty(goal_ty, db.trait_environment(function_id.into()))
 }
 
 #[track_caller]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 5e1040bc6aa..f3a5f69b2a6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -665,13 +665,21 @@ pub fn is_dyn_method(
     };
     let self_ty = trait_ref.self_type_parameter(Interner);
     if let TyKind::Dyn(d) = self_ty.kind(Interner) {
-        let is_my_trait_in_bounds =
-            d.bounds.skip_binders().as_slice(Interner).iter().any(|it| match it.skip_binders() {
-                // rustc doesn't accept `impl Foo<2> for dyn Foo<5>`, so if the trait id is equal, no matter
-                // what the generics are, we are sure that the method is come from the vtable.
-                WhereClause::Implemented(tr) => tr.trait_id == trait_ref.trait_id,
-                _ => false,
-            });
+        let is_my_trait_in_bounds = d
+            .bounds
+            .skip_binders()
+            .as_slice(Interner)
+            .iter()
+            .map(|it| it.skip_binders())
+            .flat_map(|it| match it {
+                WhereClause::Implemented(tr) => {
+                    all_super_traits(db.upcast(), from_chalk_trait_id(tr.trait_id))
+                }
+                _ => smallvec![],
+            })
+            // rustc doesn't accept `impl Foo<2> for dyn Foo<5>`, so if the trait id is equal, no matter
+            // what the generics are, we are sure that the method is come from the vtable.
+            .any(|x| x == trait_id);
         if is_my_trait_in_bounds {
             return Some(fn_params);
         }
@@ -1504,7 +1512,7 @@ fn autoderef_method_receiver(
     ty: Ty,
 ) -> Vec<(Canonical<Ty>, ReceiverAdjustments)> {
     let mut deref_chain: Vec<_> = Vec::new();
-    let mut autoderef = autoderef::Autoderef::new(table, ty, true);
+    let mut autoderef = autoderef::Autoderef::new(table, ty, false);
     while let Some((ty, derefs)) = autoderef.next() {
         deref_chain.push((
             autoderef.table.canonicalize(ty).value,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
index da5b496e141..922e49d281d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -142,7 +142,7 @@ impl<V, T> ProjectionElem<V, T> {
         closure_field: impl FnOnce(ClosureId, &Substitution, usize) -> Ty,
         krate: CrateId,
     ) -> Ty {
-        if matches!(base.data(Interner).kind, TyKind::Alias(_) | TyKind::AssociatedType(..)) {
+        if matches!(base.kind(Interner), TyKind::Alias(_) | TyKind::AssociatedType(..)) {
             base = normalize(
                 db,
                 // FIXME: we should get this from caller
@@ -151,7 +151,7 @@ impl<V, T> ProjectionElem<V, T> {
             );
         }
         match self {
-            ProjectionElem::Deref => match &base.data(Interner).kind {
+            ProjectionElem::Deref => match &base.kind(Interner) {
                 TyKind::Raw(_, inner) | TyKind::Ref(_, _, inner) => inner.clone(),
                 TyKind::Adt(adt, subst) if is_box(db, adt.0) => {
                     subst.at(Interner, 0).assert_ty_ref(Interner).clone()
@@ -161,7 +161,7 @@ impl<V, T> ProjectionElem<V, T> {
                     return TyKind::Error.intern(Interner);
                 }
             },
-            ProjectionElem::Field(f) => match &base.data(Interner).kind {
+            ProjectionElem::Field(f) => match &base.kind(Interner) {
                 TyKind::Adt(_, subst) => {
                     db.field_types(f.parent)[f.local_id].clone().substitute(Interner, subst)
                 }
@@ -170,7 +170,7 @@ impl<V, T> ProjectionElem<V, T> {
                     return TyKind::Error.intern(Interner);
                 }
             },
-            ProjectionElem::TupleOrClosureField(f) => match &base.data(Interner).kind {
+            ProjectionElem::TupleOrClosureField(f) => match &base.kind(Interner) {
                 TyKind::Tuple(_, subst) => subst
                     .as_slice(Interner)
                     .get(*f)
@@ -187,7 +187,7 @@ impl<V, T> ProjectionElem<V, T> {
                 }
             },
             ProjectionElem::ConstantIndex { .. } | ProjectionElem::Index(_) => {
-                match &base.data(Interner).kind {
+                match &base.kind(Interner) {
                     TyKind::Array(inner, _) | TyKind::Slice(inner) => inner.clone(),
                     _ => {
                         never!("Overloaded index is not a projection");
@@ -195,7 +195,7 @@ impl<V, T> ProjectionElem<V, T> {
                     }
                 }
             }
-            &ProjectionElem::Subslice { from, to } => match &base.data(Interner).kind {
+            &ProjectionElem::Subslice { from, to } => match &base.kind(Interner) {
                 TyKind::Array(inner, c) => {
                     let next_c = usize_const(
                         db,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index d7820de629a..7bd2756c14f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -484,9 +484,10 @@ pub fn interpret_mir(
     // a zero size, hoping that they are all outside of our current body. Even without a fix for #7434, we can
     // (and probably should) do better here, for example by excluding bindings outside of the target expression.
     assert_placeholder_ty_is_unused: bool,
+    trait_env: Option<Arc<TraitEnvironment>>,
 ) -> (Result<Const>, String, String) {
     let ty = body.locals[return_slot()].ty.clone();
-    let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused);
+    let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env);
     let it: Result<Const> = (|| {
         if evaluator.ptr_size() != std::mem::size_of::<usize>() {
             not_supported!("targets with different pointer size from host");
@@ -512,9 +513,9 @@ impl Evaluator<'_> {
         db: &'a dyn HirDatabase,
         owner: DefWithBodyId,
         assert_placeholder_ty_is_unused: bool,
+        trait_env: Option<Arc<TraitEnvironment>>,
     ) -> Evaluator<'a> {
         let crate_id = owner.module(db.upcast()).krate();
-        let trait_env = db.trait_environment_for_body(owner);
         Evaluator {
             stack: vec![0],
             heap: vec![0],
@@ -524,7 +525,7 @@ impl Evaluator<'_> {
             static_locations: HashMap::default(),
             db,
             random_state: oorandom::Rand64::new(0),
-            trait_env,
+            trait_env: trait_env.unwrap_or_else(|| db.trait_environment_for_body(owner)),
             crate_id,
             stdout: vec![],
             stderr: vec![],
@@ -634,7 +635,7 @@ impl Evaluator<'_> {
                     addr = addr.offset(ty_size * offset);
                 }
                 &ProjectionElem::Subslice { from, to } => {
-                    let inner_ty = match &ty.data(Interner).kind {
+                    let inner_ty = match &ty.kind(Interner) {
                         TyKind::Array(inner, _) | TyKind::Slice(inner) => inner.clone(),
                         _ => TyKind::Error.intern(Interner),
                     };
@@ -694,14 +695,14 @@ impl Evaluator<'_> {
         }
         let r = self
             .db
-            .layout_of_ty(ty.clone(), self.crate_id)
+            .layout_of_ty(ty.clone(), self.trait_env.clone())
             .map_err(|e| MirEvalError::LayoutError(e, ty.clone()))?;
         self.layout_cache.borrow_mut().insert(ty.clone(), r.clone());
         Ok(r)
     }
 
     fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Arc<Layout>> {
-        self.db.layout_of_adt(adt, subst.clone(), self.crate_id).map_err(|e| {
+        self.db.layout_of_adt(adt, subst.clone(), self.trait_env.clone()).map_err(|e| {
             MirEvalError::LayoutError(e, TyKind::Adt(chalk_ir::AdtId(adt), subst).intern(Interner))
         })
     }
@@ -793,7 +794,7 @@ impl Evaluator<'_> {
                                 .iter()
                                 .map(|it| self.operand_ty_and_eval(it, &mut locals))
                                 .collect::<Result<Vec<_>>>()?;
-                            let stack_frame = match &fn_ty.data(Interner).kind {
+                            let stack_frame = match &fn_ty.kind(Interner) {
                                 TyKind::Function(_) => {
                                     let bytes = self.eval_operand(func, &mut locals)?;
                                     self.exec_fn_pointer(
@@ -1255,7 +1256,7 @@ impl Evaluator<'_> {
                     PointerCast::ReifyFnPointer | PointerCast::ClosureFnPointer(_) => {
                         let current_ty = self.operand_ty(operand, locals)?;
                         if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) =
-                            &current_ty.data(Interner).kind
+                            &current_ty.kind(Interner)
                         {
                             let id = self.vtable_map.id(current_ty);
                             let ptr_size = self.ptr_size();
@@ -1408,8 +1409,8 @@ impl Evaluator<'_> {
         addr: Interval,
     ) -> Result<IntervalOrOwned> {
         use IntervalOrOwned::*;
-        Ok(match &target_ty.data(Interner).kind {
-            TyKind::Slice(_) => match &current_ty.data(Interner).kind {
+        Ok(match &target_ty.kind(Interner) {
+            TyKind::Slice(_) => match &current_ty.kind(Interner) {
                 TyKind::Array(_, size) => {
                     let len = match try_const_usize(self.db, size) {
                         None => {
@@ -1435,7 +1436,7 @@ impl Evaluator<'_> {
                 r.extend(vtable.to_le_bytes().into_iter());
                 Owned(r)
             }
-            TyKind::Adt(id, target_subst) => match &current_ty.data(Interner).kind {
+            TyKind::Adt(id, target_subst) => match &current_ty.kind(Interner) {
                 TyKind::Adt(current_id, current_subst) => {
                     if id != current_id {
                         not_supported!("unsizing struct with different type");
@@ -1582,10 +1583,13 @@ impl Evaluator<'_> {
                     const_id = hir_def::GeneralConstId::ConstId(c);
                     subst = s;
                 }
-                result_owner = self.db.const_eval(const_id.into(), subst).map_err(|e| {
-                    let name = const_id.name(self.db.upcast());
-                    MirEvalError::ConstEvalError(name, Box::new(e))
-                })?;
+                result_owner = self
+                    .db
+                    .const_eval(const_id.into(), subst, Some(self.trait_env.clone()))
+                    .map_err(|e| {
+                        let name = const_id.name(self.db.upcast());
+                        MirEvalError::ConstEvalError(name, Box::new(e))
+                    })?;
                 if let chalk_ir::ConstValue::Concrete(c) = &result_owner.data(Interner).value {
                     if let ConstScalar::Bytes(v, mm) = &c.interned {
                         break 'b (v, mm);
@@ -1818,9 +1822,13 @@ impl Evaluator<'_> {
                     }
                     AdtId::EnumId(e) => {
                         let layout = this.layout(ty)?;
-                        if let Some((v, l)) =
-                            detect_variant_from_bytes(&layout, this.db, this.crate_id, bytes, e)
-                        {
+                        if let Some((v, l)) = detect_variant_from_bytes(
+                            &layout,
+                            this.db,
+                            this.trait_env.clone(),
+                            bytes,
+                            e,
+                        ) {
                             let data = &this.db.enum_data(e).variants[v].variant_data;
                             let field_types = this
                                 .db
@@ -1931,7 +1939,7 @@ impl Evaluator<'_> {
     ) -> Result<Option<StackFrame>> {
         let id = from_bytes!(usize, bytes.get(self)?);
         let next_ty = self.vtable_map.ty(id)?.clone();
-        match &next_ty.data(Interner).kind {
+        match &next_ty.kind(Interner) {
             TyKind::FnDef(def, generic_args) => {
                 self.exec_fn_def(*def, generic_args, destination, args, &locals, target_bb, span)
             }
@@ -2182,7 +2190,7 @@ impl Evaluator<'_> {
             let size = self.size_of_sized(&func_ty, locals, "self type of fn trait")?;
             func_data = Interval { addr: Address::from_bytes(func_data.get(self)?)?, size };
         }
-        match &func_ty.data(Interner).kind {
+        match &func_ty.kind(Interner) {
             TyKind::FnDef(def, subst) => {
                 return self.exec_fn_def(
                     *def,
@@ -2409,7 +2417,7 @@ pub fn render_const_using_debug_impl(
     owner: ConstId,
     c: &Const,
 ) -> Result<String> {
-    let mut evaluator = Evaluator::new(db, owner.into(), false);
+    let mut evaluator = Evaluator::new(db, owner.into(), false, None);
     let locals = &Locals {
         ptr: ArenaMap::new(),
         body: db
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
index 03c083bac42..93f4b699147 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
@@ -30,7 +30,7 @@ fn eval_main(db: &TestDB, file_id: FileId) -> Result<(String, String), MirEvalEr
             db.trait_environment(func_id.into()),
         )
         .map_err(|e| MirEvalError::MirLowerError(func_id.into(), e))?;
-    let (result, stdout, stderr) = interpret_mir(db, body, false);
+    let (result, stdout, stderr) = interpret_mir(db, body, false, None);
     result?;
     Ok((stdout, stderr))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 36108587904..9f25175a3a9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -633,7 +633,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     );
                 }
                 let callee_ty = self.expr_ty_after_adjustments(*callee);
-                match &callee_ty.data(Interner).kind {
+                match &callee_ty.kind(Interner) {
                     chalk_ir::TyKind::FnDef(..) => {
                         let func = Operand::from_bytes(vec![], callee_ty.clone());
                         self.lower_call_and_args(
@@ -1229,7 +1229,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
             }
             Expr::Array(l) => match l {
                 Array::ElementList { elements, .. } => {
-                    let elem_ty = match &self.expr_ty_without_adjust(expr_id).data(Interner).kind {
+                    let elem_ty = match &self.expr_ty_without_adjust(expr_id).kind(Interner) {
                         TyKind::Array(ty, _) => ty.clone(),
                         _ => {
                             return Err(MirLowerError::TypeError(
@@ -1260,7 +1260,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     else {
                         return Ok(None);
                     };
-                    let len = match &self.expr_ty_without_adjust(expr_id).data(Interner).kind {
+                    let len = match &self.expr_ty_without_adjust(expr_id).kind(Interner) {
                         TyKind::Array(_, len) => len.clone(),
                         _ => {
                             return Err(MirLowerError::TypeError(
@@ -1341,7 +1341,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
     fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> {
         let size = self
             .db
-            .layout_of_ty(ty.clone(), self.owner.module(self.db.upcast()).krate())?
+            .layout_of_ty(ty.clone(), self.db.trait_environment_for_body(self.owner))?
             .size
             .bytes_usize();
         let bytes = match l {
@@ -1355,7 +1355,6 @@ impl<'ctx> MirLowerCtx<'ctx> {
                 return Ok(Operand::from_concrete_const(data, mm, ty));
             }
             hir_def::hir::Literal::CString(b) => {
-                let b = b.as_bytes();
                 let bytes = b.iter().copied().chain(iter::once(0)).collect::<Vec<_>>();
 
                 let mut data = Vec::with_capacity(mem::size_of::<usize>() * 2);
@@ -1418,7 +1417,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         } else {
             let name = const_id.name(self.db.upcast());
             self.db
-                .const_eval(const_id.into(), subst)
+                .const_eval(const_id.into(), subst, None)
                 .map_err(|e| MirLowerError::ConstEvalError(name, Box::new(e)))?
         };
         Ok(Operand::Constant(c))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index a8e146b096a..c837fae3fef 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -1237,6 +1237,27 @@ fn main() {
 }
 
 #[test]
+fn inherent_method_ref_self_deref_raw() {
+    check_types(
+        r#"
+struct Val;
+
+impl Val {
+    pub fn method(&self) -> u32 {
+        0
+    }
+}
+
+fn main() {
+    let foo: *const Val;
+    foo.method();
+ // ^^^^^^^^^^^^ {unknown}
+}
+"#,
+    );
+}
+
+#[test]
 fn trait_method_deref_raw() {
     check_types(
         r#"
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 5f5cd794512..542df8b3468 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -4434,3 +4434,47 @@ fn test(v: S<i32>) {
 "#,
     );
 }
+
+#[test]
+fn associated_type_in_argument() {
+    check(
+        r#"
+    trait A {
+        fn m(&self) -> i32;
+    }
+
+    fn x<T: B>(k: &<T as B>::Ty) {
+        k.m();
+    }
+
+    struct X;
+    struct Y;
+
+    impl A for X {
+        fn m(&self) -> i32 {
+            8
+        }
+    }
+
+    impl A for Y {
+        fn m(&self) -> i32 {
+            32
+        }
+    }
+
+    trait B {
+        type Ty: A;
+    }
+
+    impl B for u16 {
+        type Ty = X;
+    }
+
+    fn ttt() {
+        let inp = Y;
+        x::<u16>(&inp);
+               //^^^^ expected &X, got &Y
+    }
+    "#,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index 0c38fe5d6ab..75b8b9afa70 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -28,14 +28,15 @@ use intern::Interned;
 use rustc_hash::FxHashSet;
 use smallvec::{smallvec, SmallVec};
 use stdx::never;
+use triomphe::Arc;
 
 use crate::{
     consteval::unknown_const,
     db::HirDatabase,
     layout::{Layout, TagEncoding},
     mir::pad16,
-    ChalkTraitId, Const, ConstScalar, GenericArg, Interner, Substitution, TraitRef, TraitRefExt,
-    Ty, WhereClause,
+    ChalkTraitId, Const, ConstScalar, GenericArg, Interner, Substitution, TraitEnvironment,
+    TraitRef, TraitRefExt, Ty, WhereClause,
 };
 
 pub(crate) fn fn_traits(
@@ -417,7 +418,7 @@ impl FallibleTypeFolder<Interner> for UnevaluatedConstEvaluatorFolder<'_> {
     ) -> Result<Const, Self::Error> {
         if let chalk_ir::ConstValue::Concrete(c) = &constant.data(Interner).value {
             if let ConstScalar::UnevaluatedConst(id, subst) = &c.interned {
-                if let Ok(eval) = self.db.const_eval(*id, subst.clone()) {
+                if let Ok(eval) = self.db.const_eval(*id, subst.clone(), None) {
                     return Ok(eval);
                 } else {
                     return Ok(unknown_const(constant.data(Interner).ty.clone()));
@@ -431,10 +432,11 @@ impl FallibleTypeFolder<Interner> for UnevaluatedConstEvaluatorFolder<'_> {
 pub(crate) fn detect_variant_from_bytes<'a>(
     layout: &'a Layout,
     db: &dyn HirDatabase,
-    krate: CrateId,
+    trait_env: Arc<TraitEnvironment>,
     b: &[u8],
     e: EnumId,
 ) -> Option<(LocalEnumVariantId, &'a Layout)> {
+    let krate = trait_env.krate;
     let (var_id, var_layout) = match &layout.variants {
         hir_def::layout::Variants::Single { index } => (index.0, &*layout),
         hir_def::layout::Variants::Multiple { tag, tag_encoding, variants, .. } => {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f8d9398ae2c..b094bb7a068 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -378,11 +378,6 @@ impl ModuleDef {
             ModuleDef::BuiltinType(_) | ModuleDef::Macro(_) => return Vec::new(),
         };
 
-        let module = match self.module(db) {
-            Some(it) => it,
-            None => return Vec::new(),
-        };
-
         let mut acc = Vec::new();
 
         match self.as_def_with_body() {
@@ -390,7 +385,7 @@ impl ModuleDef {
                 def.diagnostics(db, &mut acc);
             }
             None => {
-                for diag in hir_ty::diagnostics::incorrect_case(db, module.id.krate(), id) {
+                for diag in hir_ty::diagnostics::incorrect_case(db, id) {
                     acc.push(diag.into())
                 }
             }
@@ -965,8 +960,15 @@ impl Field {
     }
 
     pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
-        db.layout_of_ty(self.ty(db).ty.clone(), self.parent.module(db).krate().into())
-            .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).into()).unwrap()))
+        db.layout_of_ty(
+            self.ty(db).ty.clone(),
+            db.trait_environment(match hir_def::VariantId::from(self.parent) {
+                hir_def::VariantId::EnumVariantId(id) => GenericDefId::EnumVariantId(id),
+                hir_def::VariantId::StructId(id) => GenericDefId::AdtId(id.into()),
+                hir_def::VariantId::UnionId(id) => GenericDefId::AdtId(id.into()),
+            }),
+        )
+        .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).into()).unwrap()))
     }
 
     pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
@@ -1246,8 +1248,12 @@ impl Adt {
             return Err(LayoutError::HasPlaceholder);
         }
         let krate = self.krate(db).id;
-        db.layout_of_adt(self.into(), Substitution::empty(Interner), krate)
-            .map(|layout| Layout(layout, db.target_data_layout(krate).unwrap()))
+        db.layout_of_adt(
+            self.into(),
+            Substitution::empty(Interner),
+            db.trait_environment(self.into()),
+        )
+        .map(|layout| Layout(layout, db.target_data_layout(krate).unwrap()))
     }
 
     /// Turns this ADT into a type. Any type parameters of the ADT will be
@@ -1820,7 +1826,7 @@ impl DefWithBody {
             // FIXME: don't ignore diagnostics for in type const
             DefWithBody::InTypeConst(_) => return,
         };
-        for diag in hir_ty::diagnostics::incorrect_case(db, krate, def.into()) {
+        for diag in hir_ty::diagnostics::incorrect_case(db, def.into()) {
             acc.push(diag.into())
         }
     }
@@ -1987,7 +1993,7 @@ impl Function {
                 return r;
             }
         };
-        let (result, stdout, stderr) = interpret_mir(db, body, false);
+        let (result, stdout, stderr) = interpret_mir(db, body, false, None);
         let mut text = match result {
             Ok(_) => "pass".to_string(),
             Err(e) => {
@@ -2156,7 +2162,7 @@ impl Const {
     }
 
     pub fn render_eval(self, db: &dyn HirDatabase) -> Result<String, ConstEvalError> {
-        let c = db.const_eval(self.id.into(), Substitution::empty(Interner))?;
+        let c = db.const_eval(self.id.into(), Substitution::empty(Interner), None)?;
         let data = &c.data(Interner);
         if let TyKind::Scalar(s) = data.ty.kind(Interner) {
             if matches!(s, Scalar::Int(_) | Scalar::Uint(_)) {
@@ -4322,7 +4328,7 @@ impl Type {
     }
 
     pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
-        db.layout_of_ty(self.ty.clone(), self.env.krate)
+        db.layout_of_ty(self.ty.clone(), self.env.clone())
             .map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap()))
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
index 2b1d8f6f013..e6179ab8b1b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
@@ -2,9 +2,10 @@ use syntax::{
     ast::{self, HasName, HasVisibility},
     AstNode,
     SyntaxKind::{
-        CONST, ENUM, FN, MACRO_DEF, MODULE, STATIC, STRUCT, TRAIT, TYPE_ALIAS, USE, VISIBILITY,
+        self, ASSOC_ITEM_LIST, CONST, ENUM, FN, MACRO_DEF, MODULE, SOURCE_FILE, STATIC, STRUCT,
+        TRAIT, TYPE_ALIAS, USE, VISIBILITY,
     },
-    T,
+    SyntaxNode, T,
 };
 
 use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
@@ -46,13 +47,11 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
 
     let (offset, target) = if let Some(keyword) = item_keyword {
         let parent = keyword.parent()?;
-        let def_kws =
-            vec![CONST, STATIC, TYPE_ALIAS, FN, MODULE, STRUCT, ENUM, TRAIT, USE, MACRO_DEF];
-        // Parent is not a definition, can't add visibility
-        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
+
+        if !can_add(&parent) {
             return None;
         }
-        // Already have visibility, do nothing
+        // Already has visibility, do nothing
         if parent.children().any(|child| child.kind() == VISIBILITY) {
             return None;
         }
@@ -86,6 +85,29 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     )
 }
 
+fn can_add(node: &SyntaxNode) -> bool {
+    const LEGAL: &[SyntaxKind] =
+        &[CONST, STATIC, TYPE_ALIAS, FN, MODULE, STRUCT, ENUM, TRAIT, USE, MACRO_DEF];
+
+    LEGAL.contains(&node.kind()) && {
+        let Some(p) = node.parent() else {
+            return false;
+        };
+
+        if p.kind() == ASSOC_ITEM_LIST {
+            p.parent()
+                .and_then(|it| ast::Impl::cast(it))
+                // inherent impls i.e 'non-trait impls' have a non-local
+                // effect, thus can have visibility even when nested.
+                // so filter them out
+                .filter(|imp| imp.for_token().is_none())
+                .is_some()
+        } else {
+            matches!(p.kind(), SOURCE_FILE | MODULE)
+        }
+    }
+}
+
 fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
     if vis.syntax().text() == "pub" {
         let target = vis.syntax().text_range();
@@ -129,6 +151,16 @@ mod tests {
         check_assist(change_visibility, "unsafe f$0n foo() {}", "pub(crate) unsafe fn foo() {}");
         check_assist(change_visibility, "$0macro foo() {}", "pub(crate) macro foo() {}");
         check_assist(change_visibility, "$0use foo;", "pub(crate) use foo;");
+        check_assist(
+            change_visibility,
+            "impl Foo { f$0n foo() {} }",
+            "impl Foo { pub(crate) fn foo() {} }",
+        );
+        check_assist(
+            change_visibility,
+            "fn bar() { impl Foo { f$0n foo() {} } }",
+            "fn bar() { impl Foo { pub(crate) fn foo() {} } }",
+        );
     }
 
     #[test]
@@ -213,4 +245,33 @@ mod tests {
         check_assist_target(change_visibility, "pub(crate)$0 fn foo() {}", "pub(crate)");
         check_assist_target(change_visibility, "struct S { $0field: u32 }", "field");
     }
+
+    #[test]
+    fn not_applicable_for_items_within_traits() {
+        check_assist_not_applicable(change_visibility, "trait Foo { f$0n run() {} }");
+        check_assist_not_applicable(change_visibility, "trait Foo { con$0st FOO: u8 = 69; }");
+        check_assist_not_applicable(change_visibility, "impl Foo for Bar { f$0n quox() {} }");
+    }
+
+    #[test]
+    fn not_applicable_for_items_within_fns() {
+        check_assist_not_applicable(change_visibility, "fn foo() { f$0n inner() {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { unsafe f$0n inner() {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { const f$0n inner() {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { con$0st FOO: u8 = 69; }");
+        check_assist_not_applicable(change_visibility, "fn foo() { en$0um Foo {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { stru$0ct Foo {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { mo$0d foo {} }");
+        check_assist_not_applicable(change_visibility, "fn foo() { $0use foo; }");
+        check_assist_not_applicable(change_visibility, "fn foo() { $0type Foo = Bar<T>; }");
+        check_assist_not_applicable(change_visibility, "fn foo() { tr$0ait Foo {} }");
+        check_assist_not_applicable(
+            change_visibility,
+            "fn foo() { impl Trait for Bar { f$0n bar() {} } }",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            "fn foo() { impl Trait for Bar { con$0st FOO: u8 = 69; } }",
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
index 92fd4f71ca5..235062bf531 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/incorrect_case.rs
@@ -545,4 +545,100 @@ pub static SomeStatic: u8 = 10;
     "#,
         );
     }
+
+    #[test]
+    fn fn_inner_items() {
+        check_diagnostics(
+            r#"
+fn main() {
+    const foo: bool = true;
+        //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+    static bar: bool = true;
+         //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+    fn BAZ() {
+     //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+        const foo: bool = true;
+            //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+        static bar: bool = true;
+             //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+        fn BAZ() {
+         //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+            let INNER_INNER = 42;
+              //^^^^^^^^^^^ 💡 warn: Variable `INNER_INNER` should have snake_case name, e.g. `inner_inner`
+        }
+
+        let INNER_LOCAL = 42;
+          //^^^^^^^^^^^ 💡 warn: Variable `INNER_LOCAL` should have snake_case name, e.g. `inner_local`
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn const_body_inner_items() {
+        check_diagnostics(
+            r#"
+const _: () = {
+    static bar: bool = true;
+         //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+    fn BAZ() {}
+     //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+
+    const foo: () = {
+        //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+        const foo: bool = true;
+            //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+        static bar: bool = true;
+             //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+        fn BAZ() {}
+         //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+    };
+};
+"#,
+        );
+    }
+
+    #[test]
+    fn static_body_inner_items() {
+        check_diagnostics(
+            r#"
+static FOO: () = {
+    const foo: bool = true;
+        //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+    fn BAZ() {}
+     //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+
+    static bar: () = {
+         //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+        const foo: bool = true;
+            //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+        static bar: bool = true;
+             //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+        fn BAZ() {}
+         //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+    };
+};
+"#,
+        );
+    }
+
+    #[test]
+    fn enum_variant_body_inner_item() {
+        check_diagnostics(
+            r#"
+enum E {
+    A = {
+        const foo: bool = true;
+            //^^^ 💡 warn: Constant `foo` should have UPPER_SNAKE_CASE name, e.g. `FOO`
+        static bar: bool = true;
+             //^^^ 💡 warn: Static variable `bar` should have UPPER_SNAKE_CASE name, e.g. `BAR`
+        fn BAZ() {}
+         //^^^ 💡 warn: Function `BAZ` should have snake_case name, e.g. `baz`
+        42
+    },
+}
+"#,
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index 577bd2bc1f8..ae97236409e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -24,7 +24,7 @@ use syntax::{
 
 use crate::{
     syntax_highlighting::{
-        escape::{highlight_escape_char, highlight_escape_string},
+        escape::{highlight_escape_byte, highlight_escape_char, highlight_escape_string},
         format::highlight_format_string,
         highlights::Highlights,
         macro_::MacroHighlighter,
@@ -471,6 +471,14 @@ fn traverse(
                 };
 
                 highlight_escape_char(hl, &char, range.start())
+            } else if ast::Byte::can_cast(token.kind())
+                && ast::Byte::can_cast(descended_token.kind())
+            {
+                let Some(byte) = ast::Byte::cast(token) else {
+                    continue;
+                };
+
+                highlight_escape_byte(hl, &byte, range.start())
             }
         }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
index 211e3588095..5913ca5e454 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/escape.rs
@@ -1,7 +1,7 @@
 //! Syntax highlighting for escape sequences
 use crate::syntax_highlighting::highlights::Highlights;
 use crate::{HlRange, HlTag};
-use syntax::ast::{Char, IsString};
+use syntax::ast::{Byte, Char, IsString};
 use syntax::{AstToken, TextRange, TextSize};
 
 pub(super) fn highlight_escape_string<T: IsString>(
@@ -10,14 +10,14 @@ pub(super) fn highlight_escape_string<T: IsString>(
     start: TextSize,
 ) {
     string.escaped_char_ranges(&mut |piece_range, char| {
-        if char.is_err() {
-            return;
-        }
-
         if string.text()[piece_range.start().into()..].starts_with('\\') {
+            let highlight = match char {
+                Ok(_) => HlTag::EscapeSequence,
+                Err(_) => HlTag::InvalidEscapeSequence,
+            };
             stack.add(HlRange {
                 range: piece_range + start,
-                highlight: HlTag::EscapeSequence.into(),
+                highlight: highlight.into(),
                 binding_hash: None,
             });
         }
@@ -26,6 +26,9 @@ pub(super) fn highlight_escape_string<T: IsString>(
 
 pub(super) fn highlight_escape_char(stack: &mut Highlights, char: &Char, start: TextSize) {
     if char.value().is_none() {
+        // We do not emit invalid escapes highlighting here. The lexer would likely be in a bad
+        // state and this token contains junks, since `'` is not a reliable delimiter (consider
+        // lifetimes). Nonetheless, parser errors should already be emitted.
         return;
     }
 
@@ -43,3 +46,24 @@ pub(super) fn highlight_escape_char(stack: &mut Highlights, char: &Char, start:
         TextRange::new(start + TextSize::from(1), start + TextSize::from(text.len() as u32 + 1));
     stack.add(HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None })
 }
+
+pub(super) fn highlight_escape_byte(stack: &mut Highlights, byte: &Byte, start: TextSize) {
+    if byte.value().is_none() {
+        // See `highlight_escape_char` for why no error highlighting here.
+        return;
+    }
+
+    let text = byte.text();
+    if !text.starts_with("b'") || !text.ends_with('\'') {
+        return;
+    }
+
+    let text = &text[2..text.len() - 1];
+    if !text.starts_with('\\') {
+        return;
+    }
+
+    let range =
+        TextRange::new(start + TextSize::from(2), start + TextSize::from(text.len() as u32 + 2));
+    stack.add(HlRange { range, highlight: HlTag::EscapeSequence.into(), binding_hash: None })
+}
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
index 2c7823069b3..bbc6b55a642 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
@@ -109,6 +109,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 ";
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
index f983109115f..6d4cdd0efe2 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
@@ -29,6 +29,7 @@ pub enum HlTag {
     Comment,
     EscapeSequence,
     FormatSpecifier,
+    InvalidEscapeSequence,
     Keyword,
     NumericLiteral,
     Operator(HlOperator),
@@ -166,6 +167,7 @@ impl HlTag {
             HlTag::CharLiteral => "char_literal",
             HlTag::Comment => "comment",
             HlTag::EscapeSequence => "escape_sequence",
+            HlTag::InvalidEscapeSequence => "invalid_escape_sequence",
             HlTag::FormatSpecifier => "format_specifier",
             HlTag::Keyword => "keyword",
             HlTag::Punctuation(punct) => match punct {
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index 9ed65fbc854..4dcbfe4eb62 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function declaration">not_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
index 567ab8ccc11..bf5505caf37 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_attributes.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="builtin_attr attribute library">allow</span><span class="parenthesis attribute">(</span><span class="none attribute">dead_code</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>
 <span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="tool_module attribute library">rustfmt</span><span class="operator attribute">::</span><span class="tool_module attribute library">skip</span><span class="attribute_bracket attribute">]</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
index 1e4c06df7ea..0d1b3c1f183 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_crate_root.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root library">foo</span><span class="semicolon">;</span>
 <span class="keyword">use</span> <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
index 5d66f832daf..dd1528ed03f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_default_library.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">use</span> <span class="module crate_root default_library library">core</span><span class="operator">::</span><span class="module default_library library">iter</span><span class="semicolon">;</span>
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 35f240d4284..d5f92aa5d47 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">//! This is a module to test doc injection.</span>
 <span class="comment documentation">//! ```</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index 87b9da46e2c..b15f7bca72b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">std</span><span class="semicolon">;</span>
 <span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">alloc</span> <span class="keyword">as</span> <span class="module crate_root default_library declaration library">abc</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
index 6b049f379ac..bdeb09d2f83 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">use</span> <span class="module">inner</span><span class="operator">::</span><span class="brace">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="module declaration">inner_mod</span><span class="brace">}</span><span class="semicolon">;</span>
 <span class="keyword">mod</span> <span class="module declaration">inner</span> <span class="brace">{</span><span class="brace">}</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index d9c3db6fbb5..f9c33b8a601 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span><span class="parenthesis">(</span><span class="value_param declaration reference">ra_fixture</span><span class="colon">:</span> <span class="punctuation">&</span><span class="builtin_type">str</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords.html
index 3900959bedf..fd3b39855e2 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_keywords.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root public">self</span><span class="semicolon">;</span>
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_lifetimes.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_lifetimes.html
index f98e0b1cda6..ec39998de26 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_lifetimes.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_lifetimes.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code>
 <span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="attribute attribute default_library library">derive</span><span class="parenthesis attribute">(</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
index 2cbbf696415..c5fcec75680 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_macros.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="module crate_root library">proc_macros</span><span class="operator">::</span><span class="macro library">mirror</span><span class="macro_bang">!</span> <span class="brace macro">{</span>
     <span class="brace macro">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_inline.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_inline.html
index 8a1d69816e6..4dcf8e5f01f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_inline.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_inline.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">//! </span><span class="struct documentation injected intra_doc_link">[Struct]</span>
 <span class="comment documentation">//! This is an intra doc injection test for modules</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_outline.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_outline.html
index c4c3e3dc260..084bbf2f742 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_outline.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_module_docs_outline.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">/// </span><span class="struct documentation injected intra_doc_link">[crate::foo::Struct]</span>
 <span class="comment documentation">/// This is an intra doc injection test for modules</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_operators.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_operators.html
index 2369071ae2a..1af4bcfbd9d 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_operators.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_operators.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="numeric_literal">1</span> <span class="arithmetic">+</span> <span class="numeric_literal">1</span> <span class="arithmetic">-</span> <span class="numeric_literal">1</span> <span class="arithmetic">*</span> <span class="numeric_literal">1</span> <span class="arithmetic">/</span> <span class="numeric_literal">1</span> <span class="arithmetic">%</span> <span class="numeric_literal">1</span> <span class="bitwise">|</span> <span class="numeric_literal">1</span> <span class="bitwise">&</span> <span class="numeric_literal">1</span> <span class="logical">!</span> <span class="numeric_literal">1</span> <span class="bitwise">^</span> <span class="numeric_literal">1</span> <span class="bitwise">&gt;&gt;</span> <span class="numeric_literal">1</span> <span class="bitwise">&lt;&lt;</span> <span class="numeric_literal">1</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_rainbow.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_rainbow.html
index bff35c897e1..ec18c3ea1f9 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_rainbow.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_rainbow.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="keyword">let</span> <span class="variable declaration reference" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index f4f164aa1de..dcac8eb7368 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration">println</span> <span class="brace">{</span>
     <span class="parenthesis">(</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>arg<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="parenthesis">(</span><span class="brace">{</span>
@@ -105,6 +106,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="char_literal">'</span><span class="escape_sequence">\x65</span><span class="char_literal">'</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="char_literal">'</span><span class="escape_sequence">\x00</span><span class="char_literal">'</span><span class="semicolon">;</span>
 
+    <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="byte_literal">b'</span><span class="escape_sequence">\xFF</span><span class="byte_literal">'</span><span class="semicolon">;</span>
+
     <span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello </span><span class="escape_sequence">{{</span><span class="string_literal macro">Hello</span><span class="escape_sequence">}}</span><span class="string_literal macro">"</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>
     <span class="comment">// from https://doc.rust-lang.org/std/fmt/index.html</span>
     <span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello"</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>                 <span class="comment">// =&gt; "Hello"</span>
@@ -159,8 +162,9 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal macro">World"</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>
     <span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal macro"> World"</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="string_literal">"</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x00</span><span class="escape_sequence">\x63</span><span class="escape_sequence">\n</span><span class="string_literal">"</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="string_literal">b"</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x00</span><span class="escape_sequence">\x63</span><span class="escape_sequence">\n</span><span class="string_literal">"</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="string_literal">"</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x00</span><span class="escape_sequence">\x63</span><span class="invalid_escape_sequence">\xFF</span><span class="escape_sequence">\u{FF}</span><span class="escape_sequence">\n</span><span class="string_literal">"</span><span class="semicolon">;</span> <span class="comment">// invalid non-UTF8 escape sequences</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="string_literal">b"</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x28</span><span class="escape_sequence">\x00</span><span class="escape_sequence">\x63</span><span class="escape_sequence">\xFF</span><span class="invalid_escape_sequence">\u{FF}</span><span class="escape_sequence">\n</span><span class="string_literal">"</span><span class="semicolon">;</span> <span class="comment">// valid bytes, invalid unicodes</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="string_literal">c"</span><span class="escape_sequence">\u{FF}</span><span class="escape_sequence">\xFF</span><span class="string_literal">"</span><span class="semicolon">;</span> <span class="comment">// valid bytes, valid unicodes</span>
     <span class="keyword">let</span> <span class="variable declaration reference">backslash</span> <span class="operator">=</span> <span class="string_literal">r"\\"</span><span class="semicolon">;</span>
 
     <span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal macro">"</span><span class="comma macro">,</span> <span class="none macro">A</span> <span class="operator macro">=</span> <span class="numeric_literal macro">92</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 654d51b8a43..c72ea54e948 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -40,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .control            { font-style: italic; }
 .reference          { font-style: italic; font-weight: bold; }
 
-.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration">id</span> <span class="brace">{</span>
     <span class="parenthesis">(</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>tt<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
index 1ee451a06d0..696aa590025 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
@@ -451,6 +451,8 @@ fn main() {
     let a = '\x65';
     let a = '\x00';
 
+    let a = b'\xFF';
+
     println!("Hello {{Hello}}");
     // from https://doc.rust-lang.org/std/fmt/index.html
     println!("Hello");                 // => "Hello"
@@ -505,8 +507,9 @@ fn main() {
     println!("Hello\nWorld");
     println!("\u{48}\x65\x6C\x6C\x6F World");
 
-    let _ = "\x28\x28\x00\x63\n";
-    let _ = b"\x28\x28\x00\x63\n";
+    let _ = "\x28\x28\x00\x63\xFF\u{FF}\n"; // invalid non-UTF8 escape sequences
+    let _ = b"\x28\x28\x00\x63\xFF\u{FF}\n"; // valid bytes, invalid unicodes
+    let _ = c"\u{FF}\xFF"; // valid bytes, valid unicodes
     let backslash = r"\\";
 
     println!("{\x41}", A = 92);
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar.rs b/src/tools/rust-analyzer/crates/parser/src/grammar.rs
index 1814e0e54c5..a868419821d 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar.rs
@@ -211,70 +211,54 @@ impl BlockLike {
 const VISIBILITY_FIRST: TokenSet = TokenSet::new(&[T![pub], T![crate]]);
 
 fn opt_visibility(p: &mut Parser<'_>, in_tuple_field: bool) -> bool {
-    match p.current() {
-        T![pub] => {
-            let m = p.start();
-            p.bump(T![pub]);
-            if p.at(T!['(']) {
-                match p.nth(1) {
-                    // test crate_visibility
-                    // pub(crate) struct S;
-                    // pub(self) struct S;
-                    // pub(super) struct S;
-
-                    // test_err crate_visibility_empty_recover
-                    // pub() struct S;
-
-                    // test pub_parens_typepath
-                    // struct B(pub (super::A));
-                    // struct B(pub (crate::A,));
-                    T![crate] | T![self] | T![super] | T![ident] | T![')'] if p.nth(2) != T![:] => {
-                        // If we are in a tuple struct, then the parens following `pub`
-                        // might be an tuple field, not part of the visibility. So in that
-                        // case we don't want to consume an identifier.
-
-                        // test pub_tuple_field
-                        // struct MyStruct(pub (u32, u32));
-                        // struct MyStruct(pub (u32));
-                        // struct MyStruct(pub ());
-                        if !(in_tuple_field && matches!(p.nth(1), T![ident] | T![')'])) {
-                            p.bump(T!['(']);
-                            paths::use_path(p);
-                            p.expect(T![')']);
-                        }
-                    }
-                    // test crate_visibility_in
-                    // pub(in super::A) struct S;
-                    // pub(in crate) struct S;
-                    T![in] => {
-                        p.bump(T!['(']);
-                        p.bump(T![in]);
-                        paths::use_path(p);
-                        p.expect(T![')']);
-                    }
-                    _ => {}
+    if !p.at(T![pub]) {
+        return false;
+    }
+
+    let m = p.start();
+    p.bump(T![pub]);
+    if p.at(T!['(']) {
+        match p.nth(1) {
+            // test crate_visibility
+            // pub(crate) struct S;
+            // pub(self) struct S;
+            // pub(super) struct S;
+
+            // test_err crate_visibility_empty_recover
+            // pub() struct S;
+
+            // test pub_parens_typepath
+            // struct B(pub (super::A));
+            // struct B(pub (crate::A,));
+            T![crate] | T![self] | T![super] | T![ident] | T![')'] if p.nth(2) != T![:] => {
+                // If we are in a tuple struct, then the parens following `pub`
+                // might be an tuple field, not part of the visibility. So in that
+                // case we don't want to consume an identifier.
+
+                // test pub_tuple_field
+                // struct MyStruct(pub (u32, u32));
+                // struct MyStruct(pub (u32));
+                // struct MyStruct(pub ());
+                if !(in_tuple_field && matches!(p.nth(1), T![ident] | T![')'])) {
+                    p.bump(T!['(']);
+                    paths::use_path(p);
+                    p.expect(T![')']);
                 }
             }
-            m.complete(p, VISIBILITY);
-            true
-        }
-        // test crate_keyword_vis
-        // crate fn main() { }
-        // struct S { crate field: u32 }
-        // struct T(crate u32);
-        T![crate] => {
-            if p.nth_at(1, T![::]) {
-                // test crate_keyword_path
-                // fn foo() { crate::foo(); }
-                return false;
+            // test crate_visibility_in
+            // pub(in super::A) struct S;
+            // pub(in crate) struct S;
+            T![in] => {
+                p.bump(T!['(']);
+                p.bump(T![in]);
+                paths::use_path(p);
+                p.expect(T![')']);
             }
-            let m = p.start();
-            p.bump(T![crate]);
-            m.complete(p, VISIBILITY);
-            true
+            _ => {}
         }
-        _ => false,
     }
+    m.complete(p, VISIBILITY);
+    true
 }
 
 fn opt_rename(p: &mut Parser<'_>) {
diff --git a/src/tools/rust-analyzer/crates/parser/src/tests/prefix_entries.rs b/src/tools/rust-analyzer/crates/parser/src/tests/prefix_entries.rs
index 11f9c34abdf..2f3c7febc04 100644
--- a/src/tools/rust-analyzer/crates/parser/src/tests/prefix_entries.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/tests/prefix_entries.rs
@@ -6,7 +6,6 @@ fn vis() {
     check(PrefixEntryPoint::Vis, "fn foo() {}", "");
     check(PrefixEntryPoint::Vis, "pub(fn foo() {}", "pub");
     check(PrefixEntryPoint::Vis, "pub(crate fn foo() {}", "pub(crate");
-    check(PrefixEntryPoint::Vis, "crate fn foo() {}", "crate");
 }
 
 #[test]
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rast
deleted file mode 100644
index 07b0210e44d..00000000000
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rast
+++ /dev/null
@@ -1,63 +0,0 @@
-SOURCE_FILE
-  FN
-    VISIBILITY
-      CRATE_KW "crate"
-    WHITESPACE " "
-    FN_KW "fn"
-    WHITESPACE " "
-    NAME
-      IDENT "main"
-    PARAM_LIST
-      L_PAREN "("
-      R_PAREN ")"
-    WHITESPACE " "
-    BLOCK_EXPR
-      STMT_LIST
-        L_CURLY "{"
-        WHITESPACE " "
-        R_CURLY "}"
-  WHITESPACE "\n"
-  STRUCT
-    STRUCT_KW "struct"
-    WHITESPACE " "
-    NAME
-      IDENT "S"
-    WHITESPACE " "
-    RECORD_FIELD_LIST
-      L_CURLY "{"
-      WHITESPACE " "
-      RECORD_FIELD
-        VISIBILITY
-          CRATE_KW "crate"
-        WHITESPACE " "
-        NAME
-          IDENT "field"
-        COLON ":"
-        WHITESPACE " "
-        PATH_TYPE
-          PATH
-            PATH_SEGMENT
-              NAME_REF
-                IDENT "u32"
-      WHITESPACE " "
-      R_CURLY "}"
-  WHITESPACE "\n"
-  STRUCT
-    STRUCT_KW "struct"
-    WHITESPACE " "
-    NAME
-      IDENT "T"
-    TUPLE_FIELD_LIST
-      L_PAREN "("
-      TUPLE_FIELD
-        VISIBILITY
-          CRATE_KW "crate"
-        WHITESPACE " "
-        PATH_TYPE
-          PATH
-            PATH_SEGMENT
-              NAME_REF
-                IDENT "u32"
-      R_PAREN ")"
-    SEMICOLON ";"
-  WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rs
deleted file mode 100644
index e2b5f2161df..00000000000
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0040_crate_keyword_vis.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-crate fn main() { }
-struct S { crate field: u32 }
-struct T(crate u32);
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rast
deleted file mode 100644
index 8d9b61630ae..00000000000
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rast
+++ /dev/null
@@ -1,33 +0,0 @@
-SOURCE_FILE
-  FN
-    FN_KW "fn"
-    WHITESPACE " "
-    NAME
-      IDENT "foo"
-    PARAM_LIST
-      L_PAREN "("
-      R_PAREN ")"
-    WHITESPACE " "
-    BLOCK_EXPR
-      STMT_LIST
-        L_CURLY "{"
-        WHITESPACE " "
-        EXPR_STMT
-          CALL_EXPR
-            PATH_EXPR
-              PATH
-                PATH
-                  PATH_SEGMENT
-                    NAME_REF
-                      CRATE_KW "crate"
-                COLON2 "::"
-                PATH_SEGMENT
-                  NAME_REF
-                    IDENT "foo"
-            ARG_LIST
-              L_PAREN "("
-              R_PAREN ")"
-          SEMICOLON ";"
-        WHITESPACE " "
-        R_CURLY "}"
-  WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rs
deleted file mode 100644
index 0f454d121d6..00000000000
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/0125_crate_keyword_path.rs
+++ /dev/null
@@ -1 +0,0 @@
-fn foo() { crate::foo(); }
diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
index e1117ac464b..e47808a2cc9 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
@@ -145,7 +145,7 @@ pub struct PackageDependency {
     pub kind: DepKind,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DepKind {
     /// Available to the library, binary, and dev targets in the package (but not the build script).
     Normal,
@@ -156,23 +156,20 @@ pub enum DepKind {
 }
 
 impl DepKind {
-    fn iter(list: &[cargo_metadata::DepKindInfo]) -> impl Iterator<Item = Self> + '_ {
-        let mut dep_kinds = Vec::new();
+    fn iter(list: &[cargo_metadata::DepKindInfo]) -> impl Iterator<Item = Self> {
+        let mut dep_kinds = [None; 3];
         if list.is_empty() {
-            dep_kinds.push(Self::Normal);
+            dep_kinds[0] = Some(Self::Normal);
         }
         for info in list {
-            let kind = match info.kind {
-                cargo_metadata::DependencyKind::Normal => Self::Normal,
-                cargo_metadata::DependencyKind::Development => Self::Dev,
-                cargo_metadata::DependencyKind::Build => Self::Build,
+            match info.kind {
+                cargo_metadata::DependencyKind::Normal => dep_kinds[0] = Some(Self::Normal),
+                cargo_metadata::DependencyKind::Development => dep_kinds[1] = Some(Self::Dev),
+                cargo_metadata::DependencyKind::Build => dep_kinds[2] = Some(Self::Build),
                 cargo_metadata::DependencyKind::Unknown => continue,
-            };
-            dep_kinds.push(kind);
+            }
         }
-        dep_kinds.sort_unstable();
-        dep_kinds.dedup();
-        dep_kinds.into_iter()
+        dep_kinds.into_iter().flatten()
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 8d68bf160a2..33d7b5ed878 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -8,7 +8,7 @@ use std::{
 
 use hir::{
     db::{DefDatabase, ExpandDatabase, HirDatabase},
-    Adt, AssocItem, Crate, DefWithBody, HasCrate, HasSource, HirDisplay, ModuleDef, Name,
+    Adt, AssocItem, Crate, DefWithBody, HasSource, HirDisplay, ModuleDef, Name,
 };
 use hir_def::{
     body::{BodySourceMap, SyntheticSyntax},
@@ -277,7 +277,7 @@ impl flags::AnalysisStats {
             let Err(e) = db.layout_of_adt(
                 hir_def::AdtId::from(a).into(),
                 Substitution::empty(Interner),
-                a.krate(db).into(),
+                db.trait_environment(a.into()),
             ) else {
                 continue;
             };
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/semantic_tokens.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/semantic_tokens.rs
index d4bb20c8f44..1fe02fc7ead 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/semantic_tokens.rs
@@ -78,6 +78,7 @@ define_semantic_token_types![
         (DERIVE_HELPER, "deriveHelper") => DECORATOR,
         (DOT, "dot"),
         (ESCAPE_SEQUENCE, "escapeSequence") => STRING,
+        (INVALID_ESCAPE_SEQUENCE, "invalidEscapeSequence") => STRING,
         (FORMAT_SPECIFIER, "formatSpecifier") => STRING,
         (GENERIC, "generic") => TYPE_PARAMETER,
         (LABEL, "label"),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/to_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/to_proto.rs
index ba3421bf9e7..7a89533a5e9 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/to_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/to_proto.rs
@@ -640,6 +640,7 @@ fn semantic_token_type_and_modifiers(
         HlTag::CharLiteral => semantic_tokens::CHAR,
         HlTag::Comment => semantic_tokens::COMMENT,
         HlTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
+        HlTag::InvalidEscapeSequence => semantic_tokens::INVALID_ESCAPE_SEQUENCE,
         HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
         HlTag::Keyword => semantic_tokens::KEYWORD,
         HlTag::None => semantic_tokens::GENERIC,
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
index 090eb89f470..87fd51d703c 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
@@ -2,7 +2,9 @@
 
 use std::borrow::Cow;
 
-use rustc_lexer::unescape::{unescape_byte, unescape_char, unescape_literal, Mode};
+use rustc_lexer::unescape::{
+    unescape_byte, unescape_c_string, unescape_char, unescape_literal, CStrUnit, Mode,
+};
 
 use crate::{
     ast::{self, AstToken},
@@ -146,6 +148,7 @@ impl QuoteOffsets {
 
 pub trait IsString: AstToken {
     const RAW_PREFIX: &'static str;
+    const MODE: Mode;
     fn is_raw(&self) -> bool {
         self.text().starts_with(Self::RAW_PREFIX)
     }
@@ -181,7 +184,7 @@ pub trait IsString: AstToken {
         let text = &self.text()[text_range_no_quotes - start];
         let offset = text_range_no_quotes.start() - start;
 
-        unescape_literal(text, Mode::Str, &mut |range, unescaped_char| {
+        unescape_literal(text, Self::MODE, &mut |range, unescaped_char| {
             let text_range =
                 TextRange::new(range.start.try_into().unwrap(), range.end.try_into().unwrap());
             cb(text_range + offset, unescaped_char);
@@ -196,6 +199,7 @@ pub trait IsString: AstToken {
 
 impl IsString for ast::String {
     const RAW_PREFIX: &'static str = "r";
+    const MODE: Mode = Mode::Str;
 }
 
 impl ast::String {
@@ -213,7 +217,7 @@ impl ast::String {
         let mut buf = String::new();
         let mut prev_end = 0;
         let mut has_error = false;
-        unescape_literal(text, Mode::Str, &mut |char_range, unescaped_char| match (
+        unescape_literal(text, Self::MODE, &mut |char_range, unescaped_char| match (
             unescaped_char,
             buf.capacity() == 0,
         ) {
@@ -239,6 +243,7 @@ impl ast::String {
 
 impl IsString for ast::ByteString {
     const RAW_PREFIX: &'static str = "br";
+    const MODE: Mode = Mode::ByteStr;
 }
 
 impl ast::ByteString {
@@ -256,7 +261,7 @@ impl ast::ByteString {
         let mut buf: Vec<u8> = Vec::new();
         let mut prev_end = 0;
         let mut has_error = false;
-        unescape_literal(text, Mode::ByteStr, &mut |char_range, unescaped_char| match (
+        unescape_literal(text, Self::MODE, &mut |char_range, unescaped_char| match (
             unescaped_char,
             buf.capacity() == 0,
         ) {
@@ -282,42 +287,70 @@ impl ast::ByteString {
 
 impl IsString for ast::CString {
     const RAW_PREFIX: &'static str = "cr";
+    const MODE: Mode = Mode::CStr;
+
+    fn escaped_char_ranges(
+        &self,
+        cb: &mut dyn FnMut(TextRange, Result<char, rustc_lexer::unescape::EscapeError>),
+    ) {
+        let text_range_no_quotes = match self.text_range_between_quotes() {
+            Some(it) => it,
+            None => return,
+        };
+
+        let start = self.syntax().text_range().start();
+        let text = &self.text()[text_range_no_quotes - start];
+        let offset = text_range_no_quotes.start() - start;
+
+        unescape_c_string(text, Self::MODE, &mut |range, unescaped_char| {
+            let text_range =
+                TextRange::new(range.start.try_into().unwrap(), range.end.try_into().unwrap());
+            // XXX: This method should only be used for highlighting ranges. The unescaped
+            // char/byte is not used. For simplicity, we return an arbitrary placeholder char.
+            cb(text_range + offset, unescaped_char.map(|_| ' '));
+        });
+    }
 }
 
 impl ast::CString {
-    pub fn value(&self) -> Option<Cow<'_, str>> {
+    pub fn value(&self) -> Option<Cow<'_, [u8]>> {
         if self.is_raw() {
             let text = self.text();
             let text =
                 &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-            return Some(Cow::Borrowed(text));
+            return Some(Cow::Borrowed(text.as_bytes()));
         }
 
         let text = self.text();
         let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
 
-        let mut buf = String::new();
+        let mut buf = Vec::new();
         let mut prev_end = 0;
         let mut has_error = false;
-        unescape_literal(text, Mode::Str, &mut |char_range, unescaped_char| match (
-            unescaped_char,
+        let mut char_buf = [0u8; 4];
+        let mut extend_unit = |buf: &mut Vec<u8>, unit: CStrUnit| match unit {
+            CStrUnit::Byte(b) => buf.push(b),
+            CStrUnit::Char(c) => buf.extend(c.encode_utf8(&mut char_buf).as_bytes()),
+        };
+        unescape_c_string(text, Self::MODE, &mut |char_range, unescaped| match (
+            unescaped,
             buf.capacity() == 0,
         ) {
-            (Ok(c), false) => buf.push(c),
+            (Ok(u), false) => extend_unit(&mut buf, u),
             (Ok(_), true) if char_range.len() == 1 && char_range.start == prev_end => {
                 prev_end = char_range.end
             }
-            (Ok(c), true) => {
+            (Ok(u), true) => {
                 buf.reserve_exact(text.len());
-                buf.push_str(&text[..prev_end]);
-                buf.push(c);
+                buf.extend(text[..prev_end].as_bytes());
+                extend_unit(&mut buf, u);
             }
             (Err(_), _) => has_error = true,
         });
 
         match (has_error, buf.capacity() == 0) {
             (true, _) => None,
-            (false, true) => Some(Cow::Borrowed(text)),
+            (false, true) => Some(Cow::Borrowed(text.as_bytes())),
             (false, false) => Some(Cow::Owned(buf)),
         }
     }
diff --git a/src/tools/rust-analyzer/docs/user/manual.adoc b/src/tools/rust-analyzer/docs/user/manual.adoc
index 31035c4b729..2cf985adabc 100644
--- a/src/tools/rust-analyzer/docs/user/manual.adoc
+++ b/src/tools/rust-analyzer/docs/user/manual.adoc
@@ -449,27 +449,24 @@ You'll need to close and reopen all .rs and Cargo files, or to restart the IDE,
 Support for the language server protocol is built into Kate through the LSP plugin, which is included by default.
 It is preconfigured to use rust-analyzer for Rust sources since Kate 21.12.
 
-Earlier versions allow you to use rust-analyzer through a simple settings change.
-In the LSP Client settings of Kate, copy the content of the third tab "default parameters" to the second tab "server configuration".
-Then in the configuration replace:
-[source,json]
-----
-        "rust": {
-            "command": ["rls"],
-            "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
-            "url": "https://github.com/rust-lang/rls",
-            "highlightingModeRegex": "^Rust$"
-        },
-----
-With
+To change rust-analyzer config options, start from the following example and put it into Kate's "User Server Settings" tab (located under the LSP Client settings):
 [source,json]
 ----
+{
+    "servers": {
         "rust": {
-            "command": ["rust-analyzer"],
-            "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
-            "url": "https://github.com/rust-lang/rust-analyzer",
-            "highlightingModeRegex": "^Rust$"
-        },
+            "initializationOptions": {
+                "cachePriming": {
+                    "enable": false
+                },
+                "check": {
+                    "allTargets": false
+                },
+                "checkOnSave": false
+            }
+        }
+    }
+}
 ----
 Then click on apply, and restart the LSP server for your rust project.
 
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index ffb5dd9079a..a4897899cab 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -35,9 +35,12 @@
         "build-base": "esbuild ./src/main.ts --bundle --outfile=out/main.js --external:vscode --format=cjs --platform=node --target=node16",
         "build": "npm run build-base -- --sourcemap",
         "watch": "npm run build-base -- --sourcemap --watch",
-        "lint": "prettier --check . && eslint -c .eslintrc.js --ext ts ./src ./tests",
-        "fix": "prettier --write . && eslint -c .eslintrc.js --ext ts ./src ./tests --fix",
-        "pretest": "tsc && npm run build",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "lint": "eslint -c .eslintrc.js --ext ts ./src ./tests",
+        "lint:fix": "npm run lint -- --fix",
+        "typecheck": "tsc",
+        "pretest": "npm run typecheck && npm run build",
         "test": "node ./out/tests/runTests.js"
     },
     "dependencies": {
@@ -1801,13 +1804,17 @@
             },
             {
                 "id": "escapeSequence",
-                "description": "Style for char escapes in strings"
+                "description": "Style for char or byte escapes in strings"
             },
             {
                 "id": "formatSpecifier",
                 "description": "Style for {} placeholders in format strings"
             },
             {
+                "id": "invalidEscapeSequence",
+                "description": "Style for invalid char or byte escapes in strings"
+            },
+            {
                 "id": "label",
                 "description": "Style for labels"
             },
diff --git a/src/tools/rust-analyzer/editors/code/src/debug.ts b/src/tools/rust-analyzer/editors/code/src/debug.ts
index f3d6238d51b..e817d680eae 100644
--- a/src/tools/rust-analyzer/editors/code/src/debug.ts
+++ b/src/tools/rust-analyzer/editors/code/src/debug.ts
@@ -66,6 +66,12 @@ export async function startDebugSession(ctx: Ctx, runnable: ra.Runnable): Promis
     return vscode.debug.startDebugging(undefined, debugConfig);
 }
 
+function createCommandLink(extensionId: string): string {
+    // do not remove the second quotes inside
+    // encodeURIComponent or it won't work
+    return `extension.open?${encodeURIComponent(`"${extensionId}"`)}`;
+}
+
 async function getDebugConfiguration(
     ctx: Ctx,
     runnable: ra.Runnable,
@@ -90,9 +96,12 @@ async function getDebugConfiguration(
     }
 
     if (!debugEngine) {
+        const commandCodeLLDB: string = createCommandLink("vadimcn.vscode-lldb");
+        const commandCpp: string = createCommandLink("ms-vscode.cpptools");
+
         await vscode.window.showErrorMessage(
-            `Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)` +
-                ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`,
+            `Install [CodeLLDB](command:${commandCodeLLDB} "Open CodeLLDB")` +
+                ` or [C/C++](command:${commandCpp} "Open C/C++") extension for debugging.`,
         );
         return;
     }
diff --git a/src/tools/rust-installer/install-template.sh b/src/tools/rust-installer/install-template.sh
index 6415644e045..b477c3eac35 100644
--- a/src/tools/rust-installer/install-template.sh
+++ b/src/tools/rust-installer/install-template.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # No undefined variables
 set -u
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
new file mode 100644
index 00000000000..9f1e8d1b3f3
--- /dev/null
+++ b/src/tools/tidy/src/issues.txt
@@ -0,0 +1,4282 @@
+/*
+============================================================
+    ⚠️⚠️⚠️NOTHING SHOULD EVER BE ADDED TO THIS LIST⚠️⚠️⚠️
+============================================================
+*/
+[
+"ui/abi/issues/issue-22565-rust-call.rs",
+"ui/abi/issues/issue-62350-sysv-neg-reg-counts.rs",
+"ui/abi/issues/issue-97463-broken-abi-leaked-uninit-data.rs",
+"ui/abi/issue-28676.rs",
+"ui/abi/issue-94223.rs",
+"ui/argument-suggestions/issue-100154.rs",
+"ui/argument-suggestions/issue-100478.rs",
+"ui/argument-suggestions/issue-101097.rs",
+"ui/argument-suggestions/issue-109831.rs",
+"ui/argument-suggestions/issue-96638.rs",
+"ui/argument-suggestions/issue-97197.rs",
+"ui/argument-suggestions/issue-97484.rs",
+"ui/argument-suggestions/issue-98894.rs",
+"ui/argument-suggestions/issue-98897.rs",
+"ui/argument-suggestions/issue-99482.rs",
+"ui/argument-suggestions/issue-112507.rs",
+"ui/argument-suggestions/issue-109425.rs",
+"ui/array-slice-vec/issue-15730.rs",
+"ui/array-slice-vec/issue-18425.rs",
+"ui/array-slice-vec/issue-69103-extra-binding-subslice.rs",
+"ui/asm/x86_64/issue-82869.rs",
+"ui/asm/x86_64/issue-89875.rs",
+"ui/asm/x86_64/issue-96797.rs",
+"ui/asm/issue-72570.rs",
+"ui/asm/issue-85247.rs",
+"ui/asm/issue-87802.rs",
+"ui/asm/issue-89305.rs",
+"ui/asm/issue-92378.rs",
+"ui/asm/issue-97490.rs",
+"ui/asm/issue-99071.rs",
+"ui/asm/issue-99122-2.rs",
+"ui/asm/issue-99122.rs",
+"ui/associated-consts/issue-102335-const.rs",
+"ui/associated-consts/issue-105330.rs",
+"ui/associated-consts/issue-24949-assoc-const-static-recursion-impl.rs",
+"ui/associated-consts/issue-24949-assoc-const-static-recursion-trait-default.rs",
+"ui/associated-consts/issue-24949-assoc-const-static-recursion-trait.rs",
+"ui/associated-consts/issue-47814.rs",
+"ui/associated-consts/issue-58022.rs",
+"ui/associated-consts/issue-63496.rs",
+"ui/associated-consts/issue-93775.rs",
+"ui/associated-consts/issue-93835.rs",
+"ui/associated-consts/issue-69020-assoc-const-arith-overflow.rs",
+"ui/associated-consts/issue-88599-ref-self.rs",
+"ui/associated-consts/issue-110933.rs",
+"ui/associated-inherent-types/issue-109299-1.rs",
+"ui/associated-inherent-types/issue-109299.rs",
+"ui/associated-inherent-types/issue-109768.rs",
+"ui/associated-inherent-types/issue-109789.rs",
+"ui/associated-inherent-types/issue-111879-0.rs",
+"ui/associated-inherent-types/issue-111879-1.rs",
+"ui/associated-inherent-types/issue-111404-1.rs",
+"ui/associated-inherent-types/issue-104260.rs",
+"ui/associated-inherent-types/issue-109790.rs",
+"ui/associated-inherent-types/issue-111404-0.rs",
+"ui/associated-inherent-types/issue-109071.rs",
+"ui/associated-item/issue-48027.rs",
+"ui/associated-item/issue-105449.rs",
+"ui/associated-item/issue-87638.rs",
+"ui/associated-type-bounds/issue-102335-ty.rs",
+"ui/associated-type-bounds/issue-104916.rs",
+"ui/associated-type-bounds/issue-71443-1.rs",
+"ui/associated-type-bounds/issue-99828.rs",
+"ui/associated-type-bounds/issue-61752.rs",
+"ui/associated-type-bounds/issue-70292.rs",
+"ui/associated-type-bounds/issue-71443-2.rs",
+"ui/associated-type-bounds/issue-73818.rs",
+"ui/associated-type-bounds/issue-79949.rs",
+"ui/associated-type-bounds/issue-81193.rs",
+"ui/associated-type-bounds/issue-83017.rs",
+"ui/associated-types/issue-18655.rs",
+"ui/associated-types/issue-19883.rs",
+"ui/associated-types/issue-20005.rs",
+"ui/associated-types/issue-20825.rs",
+"ui/associated-types/issue-22037.rs",
+"ui/associated-types/issue-22560.rs",
+"ui/associated-types/issue-22828.rs",
+"ui/associated-types/issue-23208.rs",
+"ui/associated-types/issue-23595-1.rs",
+"ui/associated-types/issue-23595-2.rs",
+"ui/associated-types/issue-25339.rs",
+"ui/associated-types/issue-25700-1.rs",
+"ui/associated-types/issue-25700-2.rs",
+"ui/associated-types/issue-25700.rs",
+"ui/associated-types/issue-26681.rs",
+"ui/associated-types/issue-27675-unchecked-bounds.rs",
+"ui/associated-types/issue-27901.rs",
+"ui/associated-types/issue-38821.rs",
+"ui/associated-types/issue-43784-associated-type.rs",
+"ui/associated-types/issue-43924.rs",
+"ui/associated-types/issue-44153.rs",
+"ui/associated-types/issue-47139-1.rs",
+"ui/associated-types/issue-47139-2.rs",
+"ui/associated-types/issue-47814.rs",
+"ui/associated-types/issue-54108.rs",
+"ui/associated-types/issue-54182-1.rs",
+"ui/associated-types/issue-54467.rs",
+"ui/associated-types/issue-55846.rs",
+"ui/associated-types/issue-59324.rs",
+"ui/associated-types/issue-62200.rs",
+"ui/associated-types/issue-63593.rs",
+"ui/associated-types/issue-64848.rs",
+"ui/associated-types/issue-64855.rs",
+"ui/associated-types/issue-65774-1.rs",
+"ui/associated-types/issue-65774-2.rs",
+"ui/associated-types/issue-72806.rs",
+"ui/associated-types/issue-85103.rs",
+"ui/associated-types/issue-87261.rs",
+"ui/associated-types/issue-19081.rs",
+"ui/associated-types/issue-20825-2.rs",
+"ui/associated-types/issue-21363.rs",
+"ui/associated-types/issue-21726.rs",
+"ui/associated-types/issue-22066.rs",
+"ui/associated-types/issue-24159.rs",
+"ui/associated-types/issue-24204.rs",
+"ui/associated-types/issue-24338.rs",
+"ui/associated-types/issue-28871.rs",
+"ui/associated-types/issue-31597.rs",
+"ui/associated-types/issue-32350.rs",
+"ui/associated-types/issue-36499.rs",
+"ui/associated-types/issue-37808.rs",
+"ui/associated-types/issue-37883.rs",
+"ui/associated-types/issue-38917.rs",
+"ui/associated-types/issue-39532.rs",
+"ui/associated-types/issue-40093.rs",
+"ui/associated-types/issue-41868.rs",
+"ui/associated-types/issue-43475.rs",
+"ui/associated-types/issue-47385.rs",
+"ui/associated-types/issue-48010.rs",
+"ui/associated-types/issue-48551.rs",
+"ui/associated-types/issue-50301.rs",
+"ui/associated-types/issue-54182-2.rs",
+"ui/associated-types/issue-63591.rs",
+"ui/associated-types/issue-64855-2.rs",
+"ui/associated-types/issue-65934.rs",
+"ui/associated-types/issue-67684.rs",
+"ui/associated-types/issue-69398.rs",
+"ui/associated-types/issue-71113.rs",
+"ui/associated-types/issue-76179.rs",
+"ui/associated-types/issue-82079.rs",
+"ui/associated-types/issue-88856.rs",
+"ui/associated-types/issue-91069.rs",
+"ui/associated-types/issue-91231.rs",
+"ui/associated-types/issue-91234.rs",
+"ui/async-await/auxiliary/issue-107036.rs",
+"ui/async-await/auxiliary/issue-72470-lib.rs",
+"ui/async-await/in-trait/issue-102138.rs",
+"ui/async-await/in-trait/issue-102219.rs",
+"ui/async-await/in-trait/issue-102310.rs",
+"ui/async-await/in-trait/issue-104678.rs",
+"ui/async-await/issues/auxiliary/issue-60674.rs",
+"ui/async-await/issues/auxiliary/issue_67893.rs",
+"ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs",
+"ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs",
+"ui/async-await/issues/issue-65419/issue-65419-generator-resume-after-completion.rs",
+"ui/async-await/issues/issue-102206.rs",
+"ui/async-await/issues/issue-107280.rs",
+"ui/async-await/issues/issue-112225-1.rs",
+"ui/async-await/issues/issue-112225-2.rs",
+"ui/async-await/issues/issue-51719.rs",
+"ui/async-await/issues/issue-51751.rs",
+"ui/async-await/issues/issue-53249.rs",
+"ui/async-await/issues/issue-54752-async-block.rs",
+"ui/async-await/issues/issue-54974.rs",
+"ui/async-await/issues/issue-55324.rs",
+"ui/async-await/issues/issue-55809.rs",
+"ui/async-await/issues/issue-58885.rs",
+"ui/async-await/issues/issue-59001.rs",
+"ui/async-await/issues/issue-59972.rs",
+"ui/async-await/issues/issue-60518.rs",
+"ui/async-await/issues/issue-60655-latebound-regions.rs",
+"ui/async-await/issues/issue-60674.rs",
+"ui/async-await/issues/issue-61187.rs",
+"ui/async-await/issues/issue-61986.rs",
+"ui/async-await/issues/issue-62009-1.rs",
+"ui/async-await/issues/issue-62009-2.rs",
+"ui/async-await/issues/issue-62097.rs",
+"ui/async-await/issues/issue-62517-1.rs",
+"ui/async-await/issues/issue-62517-2.rs",
+"ui/async-await/issues/issue-63388-1.rs",
+"ui/async-await/issues/issue-63388-2.rs",
+"ui/async-await/issues/issue-63388-3.rs",
+"ui/async-await/issues/issue-63388-4.rs",
+"ui/async-await/issues/issue-64391-2.rs",
+"ui/async-await/issues/issue-64433.rs",
+"ui/async-await/issues/issue-64477-2.rs",
+"ui/async-await/issues/issue-64477.rs",
+"ui/async-await/issues/issue-64964.rs",
+"ui/async-await/issues/issue-65159.rs",
+"ui/async-await/issues/issue-65436-raw-ptr-not-send.rs",
+"ui/async-await/issues/issue-66695-static-refs.rs",
+"ui/async-await/issues/issue-66958-non-copy-infered-type-arg.rs",
+"ui/async-await/issues/issue-67611-static-mut-refs.rs",
+"ui/async-await/issues/issue-67893.rs",
+"ui/async-await/issues/issue-69307-nested.rs",
+"ui/async-await/issues/issue-69307.rs",
+"ui/async-await/issues/issue-72312.rs",
+"ui/async-await/issues/issue-78600.rs",
+"ui/async-await/issues/issue-78654.rs",
+"ui/async-await/issues/issue-78938-async-block.rs",
+"ui/async-await/issues/issue-95307.rs",
+"ui/async-await/return-type-notation/issue-110963-early.rs",
+"ui/async-await/return-type-notation/issue-110963-late.rs",
+"ui/async-await/track-caller/issue-105134.rs",
+"ui/async-await/issue-73541-3.rs",
+"ui/async-await/issue-73541.rs",
+"ui/async-await/issue-101715.rs",
+"ui/async-await/issue-105501.rs",
+"ui/async-await/issue-107036.rs",
+"ui/async-await/issue-108572.rs",
+"ui/async-await/issue-54239-private-type-triggers-lint.rs",
+"ui/async-await/issue-60709.rs",
+"ui/async-await/issue-61076.rs",
+"ui/async-await/issue-61452.rs",
+"ui/async-await/issue-61793.rs",
+"ui/async-await/issue-61949-self-return-type.rs",
+"ui/async-await/issue-62658.rs",
+"ui/async-await/issue-63832-await-short-temporary-lifetime-1.rs",
+"ui/async-await/issue-63832-await-short-temporary-lifetime.rs",
+"ui/async-await/issue-64130-1-sync.rs",
+"ui/async-await/issue-64130-2-send.rs",
+"ui/async-await/issue-64130-3-other.rs",
+"ui/async-await/issue-64130-4-async-move.rs",
+"ui/async-await/issue-64130-non-send-future-diags.rs",
+"ui/async-await/issue-64391.rs",
+"ui/async-await/issue-66312.rs",
+"ui/async-await/issue-66387-if-without-else.rs",
+"ui/async-await/issue-67252-unnamed-future.rs",
+"ui/async-await/issue-67651.rs",
+"ui/async-await/issue-67765-async-diagnostic.rs",
+"ui/async-await/issue-68112.rs",
+"ui/async-await/issue-68523-start.rs",
+"ui/async-await/issue-68523.rs",
+"ui/async-await/issue-69446-fnmut-capture.rs",
+"ui/async-await/issue-70594.rs",
+"ui/async-await/issue-70818.rs",
+"ui/async-await/issue-71137.rs",
+"ui/async-await/issue-72442.rs",
+"ui/async-await/issue-72470-llvm-dominate.rs",
+"ui/async-await/issue-72590-type-error-sized.rs",
+"ui/async-await/issue-73050.rs",
+"ui/async-await/issue-73137.rs",
+"ui/async-await/issue-73541-1.rs",
+"ui/async-await/issue-73541-2.rs",
+"ui/async-await/issue-73741-type-err-drop-tracking.rs",
+"ui/async-await/issue-73741-type-err.rs",
+"ui/async-await/issue-74047.rs",
+"ui/async-await/issue-74072-lifetime-name-annotations.rs",
+"ui/async-await/issue-74497-lifetime-in-opaque.rs",
+"ui/async-await/issue-75785-confusing-named-region.rs",
+"ui/async-await/issue-76547.rs",
+"ui/async-await/issue-77993-2.rs",
+"ui/async-await/issue-78115.rs",
+"ui/async-await/issue-84841.rs",
+"ui/async-await/issue-86507.rs",
+"ui/async-await/issue-93197.rs",
+"ui/async-await/issue-93648.rs",
+"ui/async-await/issue-98634.rs",
+"ui/async-await/issue-70935-complex-spans.rs",
+"ui/attributes/issue-100631.rs",
+"ui/attributes/issue-105594-invalid-attr-validation.rs",
+"ui/attributes/issue-90873.rs",
+"ui/attributes/issue-40962.rs",
+"ui/auto-traits/issue-23080.rs",
+"ui/auto-traits/issue-84075.rs",
+"ui/auto-traits/issue-23080-2.rs",
+"ui/auxiliary/issue-13560-1.rs",
+"ui/auxiliary/issue-13560-2.rs",
+"ui/auxiliary/issue-13560-3.rs",
+"ui/auxiliary/issue-16822.rs",
+"ui/auxiliary/issue-18502.rs",
+"ui/auxiliary/issue-24106.rs",
+"ui/auxiliary/issue-76387.rs",
+"ui/bench/issue-32062.rs",
+"ui/binding/issue-53114-borrow-checks.rs",
+"ui/binding/issue-53114-safety-checks.rs",
+"ui/binop/issue-25916.rs",
+"ui/binop/issue-28837.rs",
+"ui/binop/issue-3820.rs",
+"ui/binop/issue-77910-1.rs",
+"ui/binop/issue-77910-2.rs",
+"ui/binop/issue-93927.rs",
+"ui/block-result/issue-11714.rs",
+"ui/block-result/issue-13428.rs",
+"ui/block-result/issue-13624.rs",
+"ui/block-result/issue-20862.rs",
+"ui/block-result/issue-22645.rs",
+"ui/block-result/issue-3563.rs",
+"ui/block-result/issue-5500.rs",
+"ui/borrowck/issue-85765-closure.rs",
+"ui/borrowck/issue-101119.rs",
+"ui/borrowck/issue-102209.rs",
+"ui/borrowck/issue-17545.rs",
+"ui/borrowck/issue-17718-static-move.rs",
+"ui/borrowck/issue-20801.rs",
+"ui/borrowck/issue-23338-params-outlive-temps-of-body.rs",
+"ui/borrowck/issue-24267-flow-exit.rs",
+"ui/borrowck/issue-25793.rs",
+"ui/borrowck/issue-29166.rs",
+"ui/borrowck/issue-31287-drop-in-guard.rs",
+"ui/borrowck/issue-33819.rs",
+"ui/borrowck/issue-41962.rs",
+"ui/borrowck/issue-42344.rs",
+"ui/borrowck/issue-45983.rs",
+"ui/borrowck/issue-46095.rs",
+"ui/borrowck/issue-46471.rs",
+"ui/borrowck/issue-47215-ice-from-drop-elab.rs",
+"ui/borrowck/issue-47646.rs",
+"ui/borrowck/issue-51117.rs",
+"ui/borrowck/issue-51301.rs",
+"ui/borrowck/issue-51348-multi-ref-mut-in-guard.rs",
+"ui/borrowck/issue-52713-bug.rs",
+"ui/borrowck/issue-53432-nested-closure-outlives-borrowed-value.rs",
+"ui/borrowck/issue-54499-field-mutation-marks-mut-as-used.rs",
+"ui/borrowck/issue-54499-field-mutation-of-moved-out-with-mut.rs",
+"ui/borrowck/issue-54499-field-mutation-of-moved-out.rs",
+"ui/borrowck/issue-54499-field-mutation-of-never-init.rs",
+"ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.rs",
+"ui/borrowck/issue-55492-borrowck-migrate-scans-parents.rs",
+"ui/borrowck/issue-58776-borrowck-scans-children.rs",
+"ui/borrowck/issue-62007-assign-box.rs",
+"ui/borrowck/issue-62007-assign-field.rs",
+"ui/borrowck/issue-62107-match-arm-scopes.rs",
+"ui/borrowck/issue-64453.rs",
+"ui/borrowck/issue-69789-iterator-mut-suggestion.rs",
+"ui/borrowck/issue-7573.rs",
+"ui/borrowck/issue-81365-1.rs",
+"ui/borrowck/issue-81365-10.rs",
+"ui/borrowck/issue-81365-11.rs",
+"ui/borrowck/issue-81365-2.rs",
+"ui/borrowck/issue-81365-3.rs",
+"ui/borrowck/issue-81365-4.rs",
+"ui/borrowck/issue-81365-5.rs",
+"ui/borrowck/issue-81365-6.rs",
+"ui/borrowck/issue-81365-7.rs",
+"ui/borrowck/issue-81365-8.rs",
+"ui/borrowck/issue-81365-9.rs",
+"ui/borrowck/issue-81899.rs",
+"ui/borrowck/issue-82032.rs",
+"ui/borrowck/issue-82462.rs",
+"ui/borrowck/issue-83309-ice-immut-in-for-loop.rs",
+"ui/borrowck/issue-83760.rs",
+"ui/borrowck/issue-85581.rs",
+"ui/borrowck/issue-85765.rs",
+"ui/borrowck/issue-87456-point-to-closure.rs",
+"ui/borrowck/issue-88434-minimal-example.rs",
+"ui/borrowck/issue-88434-removal-index-should-be-less.rs",
+"ui/borrowck/issue-91206.rs",
+"ui/borrowck/issue-92015.rs",
+"ui/borrowck/issue-92157.rs",
+"ui/borrowck/issue-93078.rs",
+"ui/borrowck/issue-111554.rs",
+"ui/borrowck/issue-45199.rs",
+"ui/borrowck/issue-103095.rs",
+"ui/borrowck/issue-103250.rs",
+"ui/borrowck/issue-103624.rs",
+"ui/borrowck/issue-104639-lifetime-order.rs",
+"ui/borrowck/issue-10876.rs",
+"ui/borrowck/issue-109271-pass-self-into-closure.rs",
+"ui/borrowck/issue-11493.rs",
+"ui/borrowck/issue-17263.rs",
+"ui/borrowck/issue-28934.rs",
+"ui/borrowck/issue-36082.rs",
+"ui/borrowck/issue-51415.rs",
+"ui/borrowck/issue-52967-edition-2018-needs-two-phase-borrows.rs",
+"ui/borrowck/issue-55552-ascribe-wildcard-to-structured-pattern.rs",
+"ui/borrowck/issue-70919-drop-in-loop.rs",
+"ui/borrowck/issue-71546.rs",
+"ui/borrowck/issue-80772.rs",
+"ui/borrowck/issue-82126-mismatched-subst-and-hir.rs",
+"ui/borrowck/issue-83924.rs",
+"ui/borrowck/issue-93093.rs",
+"ui/borrowck/issue-95079-missing-move-in-nested-closure.rs",
+"ui/box/issue-82446.rs",
+"ui/box/issue-95036.rs",
+"ui/c-variadic/issue-32201.rs",
+"ui/c-variadic/issue-86053-2.rs",
+"ui/c-variadic/issue-86053-1.rs",
+"ui/cast/issue-106883-is-empty.rs",
+"ui/cast/issue-10991.rs",
+"ui/cast/issue-17444.rs",
+"ui/cast/issue-85586.rs",
+"ui/cast/issue-88621.rs",
+"ui/cast/issue-84213.rs",
+"ui/cast/issue-89497.rs",
+"ui/closure-expected-type/issue-24421.rs",
+"ui/closure_context/issue-26046-fn-mut.rs",
+"ui/closure_context/issue-26046-fn-once.rs",
+"ui/closure_context/issue-42065.rs",
+"ui/closures/2229_closure_analysis/match/issue-87097.rs",
+"ui/closures/2229_closure_analysis/match/issue-87426.rs",
+"ui/closures/2229_closure_analysis/match/issue-87988.rs",
+"ui/closures/2229_closure_analysis/match/issue-88331.rs",
+"ui/closures/2229_closure_analysis/migrations/issue-78720.rs",
+"ui/closures/2229_closure_analysis/migrations/issue-86753.rs",
+"ui/closures/2229_closure_analysis/migrations/issue-90024-adt-correct-subst.rs",
+"ui/closures/2229_closure_analysis/run_pass/issue-87378.rs",
+"ui/closures/2229_closure_analysis/run_pass/issue-88372.rs",
+"ui/closures/2229_closure_analysis/run_pass/issue-88431.rs",
+"ui/closures/2229_closure_analysis/run_pass/issue-88476.rs",
+"ui/closures/2229_closure_analysis/issue-87378.rs",
+"ui/closures/2229_closure_analysis/issue-87987.rs",
+"ui/closures/2229_closure_analysis/issue-88118-2.rs",
+"ui/closures/2229_closure_analysis/issue-88476.rs",
+"ui/closures/2229_closure_analysis/issue-89606.rs",
+"ui/closures/2229_closure_analysis/issue-90465.rs",
+"ui/closures/2229_closure_analysis/issue-92724-needsdrop-query-cycle.rs",
+"ui/closures/2229_closure_analysis/issue_88118.rs",
+"ui/closures/issue-10398.rs",
+"ui/closures/issue-109188.rs",
+"ui/closures/issue-42463.rs",
+"ui/closures/issue-52437.rs",
+"ui/closures/issue-67123.rs",
+"ui/closures/issue-6801.rs",
+"ui/closures/issue-78720.rs",
+"ui/closures/issue-80313-mutable-borrow-in-closure.rs",
+"ui/closures/issue-80313-mutable-borrow-in-move-closure.rs",
+"ui/closures/issue-80313-mutation-in-closure.rs",
+"ui/closures/issue-80313-mutation-in-move-closure.rs",
+"ui/closures/issue-81700-mut-borrow.rs",
+"ui/closures/issue-82438-mut-without-upvar.rs",
+"ui/closures/issue-84044-drop-non-mut.rs",
+"ui/closures/issue-84128.rs",
+"ui/closures/issue-868.rs",
+"ui/closures/issue-90871.rs",
+"ui/closures/issue-99565.rs",
+"ui/closures/issue-111932.rs",
+"ui/closures/issue-72408-nested-closures-exponential.rs",
+"ui/closures/issue-101696.rs",
+"ui/closures/issue-102089-multiple-opaque-cast.rs",
+"ui/closures/issue-23012-supertrait-signature-inference.rs",
+"ui/closures/issue-41366.rs",
+"ui/closures/issue-46742.rs",
+"ui/closures/issue-48109.rs",
+"ui/closures/issue-68025.rs",
+"ui/closures/issue-87461.rs",
+"ui/closures/issue-87814-1.rs",
+"ui/closures/issue-87814-2.rs",
+"ui/closures/issue-97607.rs",
+"ui/closures/issue-113087.rs",
+"ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.rs",
+"ui/codegen/auxiliary/issue-97708-aux.rs",
+"ui/codegen/issue-101585-128bit-repeat.rs",
+"ui/codegen/issue-16602-1.rs",
+"ui/codegen/issue-16602-2.rs",
+"ui/codegen/issue-16602-3.rs",
+"ui/codegen/issue-55976.rs",
+"ui/codegen/issue-64401.rs",
+"ui/codegen/issue-97708.rs",
+"ui/codegen/issue-99551.rs",
+"ui/codegen/issue-28950.rs",
+"ui/codegen/issue-63787.rs",
+"ui/codegen/issue-82859-slice-miscompile.rs",
+"ui/codegen/issue-88043-bb-does-not-have-terminator.rs",
+"ui/codemap_tests/issue-11715.rs",
+"ui/codemap_tests/issue-28308.rs",
+"ui/coercion/auxiliary/issue-39823.rs",
+"ui/coercion/issue-14589.rs",
+"ui/coercion/issue-39823.rs",
+"ui/coercion/issue-53475.rs",
+"ui/coercion/issue-73886.rs",
+"ui/coercion/issue-3794.rs",
+"ui/coercion/issue-101066.rs",
+"ui/coercion/issue-36007.rs",
+"ui/coercion/issue-37655.rs",
+"ui/coercion/issue-88097.rs",
+"ui/coherence/issue-85026.rs",
+"ui/coherence/issue-99663-2.rs",
+"ui/coherence/issue-99663.rs",
+"ui/command/issue-10626.rs",
+"ui/compare-method/issue-90444.rs",
+"ui/conditional-compilation/issue-34028.rs",
+"ui/confuse-field-and-method/issue-18343.rs",
+"ui/confuse-field-and-method/issue-2392.rs",
+"ui/confuse-field-and-method/issue-32128.rs",
+"ui/confuse-field-and-method/issue-33784.rs",
+"ui/const-generics/generic_arg_infer/issue-91614.rs",
+"ui/const-generics/generic_const_exprs/auxiliary/issue-94287-aux.rs",
+"ui/const-generics/generic_const_exprs/issue-100217.rs",
+"ui/const-generics/generic_const_exprs/issue-102768.rs",
+"ui/const-generics/generic_const_exprs/issue-105257.rs",
+"ui/const-generics/generic_const_exprs/issue-105608.rs",
+"ui/const-generics/generic_const_exprs/issue-69654.rs",
+"ui/const-generics/generic_const_exprs/issue-73298.rs",
+"ui/const-generics/generic_const_exprs/issue-73899.rs",
+"ui/const-generics/generic_const_exprs/issue-74713.rs",
+"ui/const-generics/generic_const_exprs/issue-76595.rs",
+"ui/const-generics/generic_const_exprs/issue-79518-default_trait_method_normalization.rs",
+"ui/const-generics/generic_const_exprs/issue-80742.rs",
+"ui/const-generics/generic_const_exprs/issue-82268.rs",
+"ui/const-generics/generic_const_exprs/issue-83765.rs",
+"ui/const-generics/generic_const_exprs/issue-83972.rs",
+"ui/const-generics/generic_const_exprs/issue-84669.rs",
+"ui/const-generics/generic_const_exprs/issue-85848.rs",
+"ui/const-generics/generic_const_exprs/issue-94287.rs",
+"ui/const-generics/generic_const_exprs/issue-86710.rs",
+"ui/const-generics/generic_const_exprs/issue-100360.rs",
+"ui/const-generics/generic_const_exprs/issue-102074.rs",
+"ui/const-generics/generic_const_exprs/issue-62504.rs",
+"ui/const-generics/generic_const_exprs/issue-72787.rs",
+"ui/const-generics/generic_const_exprs/issue-72819-generic-in-const-eval.rs",
+"ui/const-generics/generic_const_exprs/issue-74634.rs",
+"ui/const-generics/generic_const_exprs/issue-80561-incorrect-param-env.rs",
+"ui/const-generics/generic_const_exprs/issue-84408.rs",
+"ui/const-generics/generic_const_exprs/issue-89851.rs",
+"ui/const-generics/generic_const_exprs/issue-90847.rs",
+"ui/const-generics/generic_const_exprs/issue-94293.rs",
+"ui/const-generics/generic_const_exprs/issue-97047-ice-1.rs",
+"ui/const-generics/generic_const_exprs/issue-97047-ice-2.rs",
+"ui/const-generics/generic_const_exprs/issue-99647.rs",
+"ui/const-generics/generic_const_exprs/issue-99705.rs",
+"ui/const-generics/generic_const_exprs/issue-109141.rs",
+"ui/const-generics/generic_const_exprs/issue-96699.rs",
+"ui/const-generics/infer/issue-77092.rs",
+"ui/const-generics/issues/issue-105037.rs",
+"ui/const-generics/issues/issue-56445-2.rs",
+"ui/const-generics/issues/issue-56445-3.rs",
+"ui/const-generics/issues/issue-61336-1.rs",
+"ui/const-generics/issues/issue-61336-2.rs",
+"ui/const-generics/issues/issue-61336.rs",
+"ui/const-generics/issues/issue-61432.rs",
+"ui/const-generics/issues/issue-62187-encountered-polymorphic-const.rs",
+"ui/const-generics/issues/issue-67185-2.rs",
+"ui/const-generics/issues/issue-68104-print-stack-overflow.rs",
+"ui/const-generics/issues/issue-69654-run-pass.rs",
+"ui/const-generics/issues/issue-70125-1.rs",
+"ui/const-generics/issues/issue-70125-2.rs",
+"ui/const-generics/issues/issue-70180-1-stalled_on.rs",
+"ui/const-generics/issues/issue-70180-2-stalled_on.rs",
+"ui/const-generics/issues/issue-71202.rs",
+"ui/const-generics/issues/issue-72845.rs",
+"ui/const-generics/issues/issue-73260.rs",
+"ui/const-generics/issues/issue-76701-ty-param-in-const.rs",
+"ui/const-generics/issues/issue-79674.rs",
+"ui/const-generics/issues/issue-80062.rs",
+"ui/const-generics/issues/issue-80375.rs",
+"ui/const-generics/issues/issue-82956.rs",
+"ui/const-generics/issues/issue-83249.rs",
+"ui/const-generics/issues/issue-83288.rs",
+"ui/const-generics/issues/issue-83466.rs",
+"ui/const-generics/issues/issue-83765.rs",
+"ui/const-generics/issues/issue-84659.rs",
+"ui/const-generics/issues/issue-86530.rs",
+"ui/const-generics/issues/issue-86535-2.rs",
+"ui/const-generics/issues/issue-86535.rs",
+"ui/const-generics/issues/issue-86820.rs",
+"ui/const-generics/issues/issue-87470.rs",
+"ui/const-generics/issues/issue-87493.rs",
+"ui/const-generics/issues/issue-87964.rs",
+"ui/const-generics/issues/issue-88997.rs",
+"ui/const-generics/issues/issue-89146.rs",
+"ui/const-generics/issues/issue-89320.rs",
+"ui/const-generics/issues/issue-89334.rs",
+"ui/const-generics/issues/issue-90318.rs",
+"ui/const-generics/issues/issue-90364.rs",
+"ui/const-generics/issues/issue-90455.rs",
+"ui/const-generics/issues/issue-97634.rs",
+"ui/const-generics/issues/issue-98629.rs",
+"ui/const-generics/issues/issue-100313.rs",
+"ui/const-generics/issues/issue-87076.rs",
+"ui/const-generics/issues/issue-97278.rs",
+"ui/const-generics/issues/issue-99641.rs",
+"ui/const-generics/issues/issue-105821.rs",
+"ui/const-generics/issues/issue-56445-1.rs",
+"ui/const-generics/issues/issue-60818-struct-constructors.rs",
+"ui/const-generics/issues/issue-61422.rs",
+"ui/const-generics/issues/issue-62878.rs",
+"ui/const-generics/issues/issue-63322-forbid-dyn.rs",
+"ui/const-generics/issues/issue-64519.rs",
+"ui/const-generics/issues/issue-66596-impl-trait-for-str-const-arg.rs",
+"ui/const-generics/issues/issue-66906.rs",
+"ui/const-generics/issues/issue-67185-1.rs",
+"ui/const-generics/issues/issue-67375.rs",
+"ui/const-generics/issues/issue-67739.rs",
+"ui/const-generics/issues/issue-67945-1.rs",
+"ui/const-generics/issues/issue-67945-2.rs",
+"ui/const-generics/issues/issue-67945-3.rs",
+"ui/const-generics/issues/issue-67945-4.rs",
+"ui/const-generics/issues/issue-68366.rs",
+"ui/const-generics/issues/issue-68596.rs",
+"ui/const-generics/issues/issue-68615-adt.rs",
+"ui/const-generics/issues/issue-68615-array.rs",
+"ui/const-generics/issues/issue-70167.rs",
+"ui/const-generics/issues/issue-70225.rs",
+"ui/const-generics/issues/issue-70273-assoc-fn.rs",
+"ui/const-generics/issues/issue-71169.rs",
+"ui/const-generics/issues/issue-71381.rs",
+"ui/const-generics/issues/issue-71382.rs",
+"ui/const-generics/issues/issue-71547.rs",
+"ui/const-generics/issues/issue-71611.rs",
+"ui/const-generics/issues/issue-71986.rs",
+"ui/const-generics/issues/issue-72352.rs",
+"ui/const-generics/issues/issue-73120.rs",
+"ui/const-generics/issues/issue-73491.rs",
+"ui/const-generics/issues/issue-73727-static-reference-array-const-param.rs",
+"ui/const-generics/issues/issue-74101.rs",
+"ui/const-generics/issues/issue-74255.rs",
+"ui/const-generics/issues/issue-74906.rs",
+"ui/const-generics/issues/issue-74950.rs",
+"ui/const-generics/issues/issue-75047.rs",
+"ui/const-generics/issues/issue-75299.rs",
+"ui/const-generics/issues/issue-85031-2.rs",
+"ui/const-generics/issues/issue-86033.rs",
+"ui/const-generics/issues/issue-88119.rs",
+"ui/const-generics/issues/issue-88468.rs",
+"ui/const-generics/issues/issue-89304.rs",
+"ui/const-generics/issues/issue-92186.rs",
+"ui/const-generics/issues/issue-96654.rs",
+"ui/const-generics/parser-error-recovery/issue-89013-no-assoc.rs",
+"ui/const-generics/parser-error-recovery/issue-89013-no-kw.rs",
+"ui/const-generics/parser-error-recovery/issue-89013-type.rs",
+"ui/const-generics/parser-error-recovery/issue-89013.rs",
+"ui/const-generics/type-dependent/issue-61936.rs",
+"ui/const-generics/type-dependent/issue-63695.rs",
+"ui/const-generics/type-dependent/issue-69816.rs",
+"ui/const-generics/type-dependent/issue-70507.rs",
+"ui/const-generics/type-dependent/issue-71382.rs",
+"ui/const-generics/type-dependent/issue-71805.rs",
+"ui/const-generics/type-dependent/issue-67144-1.rs",
+"ui/const-generics/type-dependent/issue-67144-2.rs",
+"ui/const-generics/type-dependent/issue-70217.rs",
+"ui/const-generics/type-dependent/issue-70586.rs",
+"ui/const-generics/type-dependent/issue-71348.rs",
+"ui/const-generics/type-dependent/issue-73730.rs",
+"ui/const-generics/issue-46511.rs",
+"ui/const-generics/issue-70408.rs",
+"ui/const-generics/issue-93647.rs",
+"ui/const-generics/issue-112505-overflow.rs",
+"ui/const-generics/issue-66451.rs",
+"ui/const-generics/issue-80471.rs",
+"ui/const-generics/issue-102124.rs",
+"ui/const-generics/issue-105689.rs",
+"ui/const-generics/issue-106419-struct-with-multiple-const-params.rs",
+"ui/const-generics/issue-97007.rs",
+"ui/const_prop/issue-102553.rs",
+"ui/const_prop/issue-86351.rs",
+"ui/consts/auxiliary/issue-17718-aux.rs",
+"ui/consts/auxiliary/issue-63226.rs",
+"ui/consts/const-eval/issue-100878.rs",
+"ui/consts/const-eval/issue-104390.rs",
+"ui/consts/const-eval/issue-43197.rs",
+"ui/consts/const-eval/issue-44578.rs",
+"ui/consts/const-eval/issue-49296.rs",
+"ui/consts/const-eval/issue-50814-2.rs",
+"ui/consts/const-eval/issue-50814.rs",
+"ui/consts/const-eval/issue-64908.rs",
+"ui/consts/const-eval/issue-64970.rs",
+"ui/consts/const-eval/issue-65394.rs",
+"ui/consts/const-eval/issue-84957-const-str-as-bytes.rs",
+"ui/consts/const-eval/issue-85155.rs",
+"ui/consts/const-eval/issue-85907.rs",
+"ui/consts/const-eval/issue-91827-extern-types.rs",
+"ui/consts/const-eval/issue-52475.rs",
+"ui/consts/const-eval/issue-70723.rs",
+"ui/consts/const-eval/issue-47971.rs",
+"ui/consts/const-eval/issue-50706.rs",
+"ui/consts/const-eval/issue-51300.rs",
+"ui/consts/const-eval/issue-53157.rs",
+"ui/consts/const-eval/issue-53401.rs",
+"ui/consts/const-eval/issue-55541.rs",
+"ui/consts/const-eval/issue-70804-fn-subtyping.rs",
+"ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier-2.rs",
+"ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier.rs",
+"ui/consts/const-mut-refs/issue-76510.rs",
+"ui/consts/const_in_pattern/issue-44333.rs",
+"ui/consts/const_in_pattern/issue-62614.rs",
+"ui/consts/const_in_pattern/issue-78057.rs",
+"ui/consts/const_in_pattern/issue-53708.rs",
+"ui/consts/const_in_pattern/issue-65466.rs",
+"ui/consts/const_in_pattern/issue-73431.rs",
+"ui/consts/control-flow/issue-46843.rs",
+"ui/consts/control-flow/issue-50577.rs",
+"ui/consts/extra-const-ub/issue-100771.rs",
+"ui/consts/extra-const-ub/issue-101034.rs",
+"ui/consts/issue-102117.rs",
+"ui/consts/issue-103790.rs",
+"ui/consts/issue-104609.rs",
+"ui/consts/issue-104768.rs",
+"ui/consts/issue-13902.rs",
+"ui/consts/issue-17458.rs",
+"ui/consts/issue-17718-borrow-interior.rs",
+"ui/consts/issue-17718-const-bad-values.rs",
+"ui/consts/issue-17718-const-borrow.rs",
+"ui/consts/issue-17718-constants-not-static.rs",
+"ui/consts/issue-17718-references.rs",
+"ui/consts/issue-17718.rs",
+"ui/consts/issue-17756.rs",
+"ui/consts/issue-18294.rs",
+"ui/consts/issue-19244.rs",
+"ui/consts/issue-21562.rs",
+"ui/consts/issue-21721.rs",
+"ui/consts/issue-23833.rs",
+"ui/consts/issue-23968-const-not-overflow.rs",
+"ui/consts/issue-25826.rs",
+"ui/consts/issue-27890.rs",
+"ui/consts/issue-28113.rs",
+"ui/consts/issue-29914-2.rs",
+"ui/consts/issue-29914-3.rs",
+"ui/consts/issue-29914.rs",
+"ui/consts/issue-29927-1.rs",
+"ui/consts/issue-29927.rs",
+"ui/consts/issue-32829-2.rs",
+"ui/consts/issue-32829.rs",
+"ui/consts/issue-33537.rs",
+"ui/consts/issue-34784.rs",
+"ui/consts/issue-36163.rs",
+"ui/consts/issue-37222.rs",
+"ui/consts/issue-37550.rs",
+"ui/consts/issue-37991.rs",
+"ui/consts/issue-39974.rs",
+"ui/consts/issue-43105.rs",
+"ui/consts/issue-44415.rs",
+"ui/consts/issue-46553.rs",
+"ui/consts/issue-50439.rs",
+"ui/consts/issue-52023-array-size-pointer-cast.rs",
+"ui/consts/issue-52060.rs",
+"ui/consts/issue-54224.rs",
+"ui/consts/issue-54348.rs",
+"ui/consts/issue-54582.rs",
+"ui/consts/issue-54954.rs",
+"ui/consts/issue-56164.rs",
+"ui/consts/issue-58435-ice-with-assoc-const.rs",
+"ui/consts/issue-64506.rs",
+"ui/consts/issue-64662.rs",
+"ui/consts/issue-66693-panic-in-array-len.rs",
+"ui/consts/issue-66693.rs",
+"ui/consts/issue-68542-closure-in-array-len.rs",
+"ui/consts/issue-69191-ice-on-uninhabited-enum-field.rs",
+"ui/consts/issue-69310-array-size-lit-wrong-ty.rs",
+"ui/consts/issue-69312.rs",
+"ui/consts/issue-69488.rs",
+"ui/consts/issue-69532.rs",
+"ui/consts/issue-70773-mir-typeck-lt-norm.rs",
+"ui/consts/issue-70942-trait-vs-impl-mismatch.rs",
+"ui/consts/issue-73976-monomorphic.rs",
+"ui/consts/issue-73976-polymorphic.rs",
+"ui/consts/issue-76064.rs",
+"ui/consts/issue-77062-large-zst-array.rs",
+"ui/consts/issue-78655.rs",
+"ui/consts/issue-79137-toogeneric.rs",
+"ui/consts/issue-83182.rs",
+"ui/consts/issue-87046.rs",
+"ui/consts/issue-90762.rs",
+"ui/consts/issue-90878-2.rs",
+"ui/consts/issue-90878-3.rs",
+"ui/consts/issue-90878.rs",
+"ui/consts/issue-91434.rs",
+"ui/consts/issue-94675.rs",
+"ui/consts/issue-104155.rs",
+"ui/consts/issue-104396.rs",
+"ui/consts/issue-13837.rs",
+"ui/consts/issue-16538.rs",
+"ui/consts/issue-28822.rs",
+"ui/consts/issue-29798.rs",
+"ui/consts/issue-33903.rs",
+"ui/consts/issue-3521.rs",
+"ui/consts/issue-37550-1.rs",
+"ui/consts/issue-39161-bogus-error.rs",
+"ui/consts/issue-47789.rs",
+"ui/consts/issue-54387.rs",
+"ui/consts/issue-62045.rs",
+"ui/consts/issue-63226.rs",
+"ui/consts/issue-63952.rs",
+"ui/consts/issue-64059.rs",
+"ui/consts/issue-65348.rs",
+"ui/consts/issue-66342.rs",
+"ui/consts/issue-66345.rs",
+"ui/consts/issue-66397.rs",
+"ui/consts/issue-66787.rs",
+"ui/consts/issue-67529.rs",
+"ui/consts/issue-67640.rs",
+"ui/consts/issue-67641.rs",
+"ui/consts/issue-67696-const-prop-ice.rs",
+"ui/consts/issue-67862.rs",
+"ui/consts/issue-68264-overflow.rs",
+"ui/consts/issue-68684.rs",
+"ui/consts/issue-6991.rs",
+"ui/consts/issue-79137-monomorphic.rs",
+"ui/consts/issue-79152-const-array-index.rs",
+"ui/consts/issue-79690.rs",
+"ui/consts/issue-88071.rs",
+"ui/consts/issue-88649.rs",
+"ui/consts/issue-89088.rs",
+"ui/consts/issue-90870.rs",
+"ui/consts/issue-91560.rs",
+"ui/consts/issue-94371.rs",
+"ui/consts/issue-96169.rs",
+"ui/consts/issue-17074.rs",
+"ui/cross-crate/issue-64872/issue-64872.rs",
+"ui/cycle-trait/issue-12511.rs",
+"ui/debuginfo/issue-105386-debuginfo-ub.rs",
+"ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs",
+"ui/deprecation/issue-84637-deprecated-associated-function.rs",
+"ui/derived-errors/issue-30580.rs",
+"ui/derived-errors/issue-31997-1.rs",
+"ui/derived-errors/issue-31997.rs",
+"ui/derives/issue-36617.rs",
+"ui/derives/issue-43023.rs",
+"ui/derives/issue-91492.rs",
+"ui/derives/issue-91550.rs",
+"ui/derives/issue-97343.rs",
+"ui/deriving/issue-103157.rs",
+"ui/deriving/issue-15689-1.rs",
+"ui/deriving/issue-19358.rs",
+"ui/deriving/issue-3935.rs",
+"ui/deriving/issue-58319.rs",
+"ui/deriving/issue-105101.rs",
+"ui/deriving/issue-15689-2.rs",
+"ui/deriving/issue-6341.rs",
+"ui/deriving/issue-89188-gat-hrtb.rs",
+"ui/did_you_mean/issue-103909.rs",
+"ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.rs",
+"ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.rs",
+"ui/did_you_mean/issue-31424.rs",
+"ui/did_you_mean/issue-34126.rs",
+"ui/did_you_mean/issue-34337.rs",
+"ui/did_you_mean/issue-35937.rs",
+"ui/did_you_mean/issue-36798.rs",
+"ui/did_you_mean/issue-36798_unknown_field.rs",
+"ui/did_you_mean/issue-37139.rs",
+"ui/did_you_mean/issue-38054-do-not-show-unresolved-names.rs",
+"ui/did_you_mean/issue-38147-1.rs",
+"ui/did_you_mean/issue-38147-2.rs",
+"ui/did_you_mean/issue-38147-3.rs",
+"ui/did_you_mean/issue-38147-4.rs",
+"ui/did_you_mean/issue-39544.rs",
+"ui/did_you_mean/issue-39802-show-5-trait-impls.rs",
+"ui/did_you_mean/issue-40006.rs",
+"ui/did_you_mean/issue-40396.rs",
+"ui/did_you_mean/issue-40823.rs",
+"ui/did_you_mean/issue-42599_available_fields_note.rs",
+"ui/did_you_mean/issue-42764.rs",
+"ui/did_you_mean/issue-43871-enum-instead-of-variant.rs",
+"ui/did_you_mean/issue-46718-struct-pattern-dotdotdot.rs",
+"ui/did_you_mean/issue-46836-identifier-not-instead-of-negation.rs",
+"ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.rs",
+"ui/did_you_mean/issue-49746-unicode-confusable-in-float-literal-expt.rs",
+"ui/did_you_mean/issue-53280-expected-float-found-integer-literal.rs",
+"ui/did_you_mean/issue-54109-and_instead_of_ampersands.rs",
+"ui/did_you_mean/issue-56028-there-is-an-enum-variant.rs",
+"ui/did_you_mean/issue-87830-try-brackets-for-arrays.rs",
+"ui/did_you_mean/issue-93210-ignore-doc-hidden.rs",
+"ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs",
+"ui/did_you_mean/issue-54109-without-witness.rs",
+"ui/drop/auxiliary/issue-10028.rs",
+"ui/drop/issue-10028.rs",
+"ui/drop/issue-21486.rs",
+"ui/drop/issue-23338-ensure-param-drop-order.rs",
+"ui/drop/issue-2734.rs",
+"ui/drop/issue-2735-2.rs",
+"ui/drop/issue-2735-3.rs",
+"ui/drop/issue-2735.rs",
+"ui/drop/issue-30018-nopanic.rs",
+"ui/drop/issue-35546.rs",
+"ui/drop/issue-48962.rs",
+"ui/drop/issue-90752-raw-ptr-shenanigans.rs",
+"ui/drop/issue-90752.rs",
+"ui/drop/issue-979.rs",
+"ui/drop/issue-100276.rs",
+"ui/drop/issue-103107.rs",
+"ui/drop/issue-110682.rs",
+"ui/drop/issue-17718-const-destructors.rs",
+"ui/dropck/issue-24805-dropck-itemless.rs",
+"ui/dropck/issue-28498-ugeh-with-lifetime-param.rs",
+"ui/dropck/issue-28498-ugeh-with-passed-to-fn.rs",
+"ui/dropck/issue-28498-ugeh-with-trait-bound.rs",
+"ui/dropck/issue-29844.rs",
+"ui/dropck/issue-34053.rs",
+"ui/dropck/issue-38868.rs",
+"ui/dropck/issue-54943-1.rs",
+"ui/dropck/issue-54943-2.rs",
+"ui/dst/issue-90528-unsizing-suggestion-1.rs",
+"ui/dst/issue-90528-unsizing-suggestion-2.rs",
+"ui/dst/issue-90528-unsizing-suggestion-3.rs",
+"ui/dst/issue-90528-unsizing-suggestion-4.rs",
+"ui/dyn-keyword/issue-56327-dyn-trait-in-macro-is-okay.rs",
+"ui/dyn-star/issue-102430.rs",
+"ui/empty/issue-37026.rs",
+"ui/enum-discriminant/auxiliary/issue-41394.rs",
+"ui/enum-discriminant/issue-104519.rs",
+"ui/enum-discriminant/issue-41394-rpass.rs",
+"ui/enum-discriminant/issue-41394.rs",
+"ui/enum-discriminant/issue-43398.rs",
+"ui/enum-discriminant/issue-51582.rs",
+"ui/enum-discriminant/issue-61696.rs",
+"ui/enum-discriminant/issue-70453-generics-in-discr-ice-2.rs",
+"ui/enum-discriminant/issue-70453-generics-in-discr-ice.rs",
+"ui/enum-discriminant/issue-70453-polymorphic-ctfe.rs",
+"ui/enum-discriminant/issue-70509-partial_eq.rs",
+"ui/enum-discriminant/issue-72554.rs",
+"ui/enum-discriminant/issue-90038.rs",
+"ui/enum-discriminant/issue-50689.rs",
+"ui/enum-discriminant/issue-46519.rs",
+"ui/enum/issue-42747.rs",
+"ui/enum/issue-67945-1.rs",
+"ui/enum/issue-67945-2.rs",
+"ui/enum/issue-1821.rs",
+"ui/error-codes/e0119/auxiliary/issue-23563-a.rs",
+"ui/error-codes/e0119/issue-23563.rs",
+"ui/error-codes/e0119/issue-27403.rs",
+"ui/error-codes/e0119/issue-28981.rs",
+"ui/errors/issue-99572-impl-trait-on-pointer.rs",
+"ui/errors/issue-104621-extern-bad-file.rs",
+"ui/errors/issue-104621-extern-not-file.rs",
+"ui/errors/issue-89280-emitter-overflow-splice-lines.rs",
+"ui/expr/if/issue-4201.rs",
+"ui/extenv/issue-55897.rs",
+"ui/extenv/issue-110547.rs",
+"ui/extern/auxiliary/issue-80074-macro.rs",
+"ui/extern/issue-10025.rs",
+"ui/extern/issue-10763.rs",
+"ui/extern/issue-10764-rpass.rs",
+"ui/extern/issue-13655.rs",
+"ui/extern/issue-36122-accessing-externed-dst.rs",
+"ui/extern/issue-112363-extern-item-where-clauses-debug-ice.rs",
+"ui/extern/issue-1251.rs",
+"ui/extern/issue-28324.rs",
+"ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs",
+"ui/extern/issue-64655-extern-rust-must-allow-unwind.rs",
+"ui/extern/issue-80074.rs",
+"ui/extern/issue-95829.rs",
+"ui/feature-gates/issue-43106-gating-of-bench.rs",
+"ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs",
+"ui/feature-gates/issue-43106-gating-of-derive-2.rs",
+"ui/feature-gates/issue-43106-gating-of-derive.rs",
+"ui/feature-gates/issue-43106-gating-of-macro_use.rs",
+"ui/feature-gates/issue-43106-gating-of-proc_macro_derive.rs",
+"ui/feature-gates/issue-43106-gating-of-stable.rs",
+"ui/feature-gates/issue-43106-gating-of-test.rs",
+"ui/feature-gates/issue-43106-gating-of-unstable.rs",
+"ui/feature-gates/issue-49983-see-issue-0.rs",
+"ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs",
+"ui/feature-gates/issue-43106-gating-of-deprecated.rs",
+"ui/feature-gates/issue-43106-gating-of-macro_escape.rs",
+"ui/fmt/issue-103826.rs",
+"ui/fmt/issue-104142.rs",
+"ui/fmt/issue-75307.rs",
+"ui/fmt/issue-86085.rs",
+"ui/fmt/issue-89173.rs",
+"ui/fmt/issue-91556.rs",
+"ui/fn/issue-3044.rs",
+"ui/fn/issue-3099.rs",
+"ui/fn/issue-3904.rs",
+"ui/fn/issue-39259.rs",
+"ui/fn/issue-80179.rs",
+"ui/for-loop-while/issue-2216.rs",
+"ui/for-loop-while/issue-51345.rs",
+"ui/for-loop-while/issue-69841.rs",
+"ui/for-loop-while/issue-1257.rs",
+"ui/for/issue-20605.rs",
+"ui/foreign/issue-91370-foreign-fn-block-impl.rs",
+"ui/foreign/issue-74120-lowering-of-ffi-block-bodies.rs",
+"ui/foreign/issue-99276-same-type-lifetimes.rs",
+"ui/function-pointer/issue-102289.rs",
+"ui/functions-closures/closure-expected-type/issue-38714.rs",
+"ui/generator/issue-113279.rs",
+"ui/generator/issue-44197.rs",
+"ui/generator/issue-48048.rs",
+"ui/generator/issue-52398.rs",
+"ui/generator/issue-64620-yield-array-element.rs",
+"ui/generator/issue-69039.rs",
+"ui/generator/issue-88653.rs",
+"ui/generator/issue-91477.rs",
+"ui/generator/issue-102645.rs",
+"ui/generator/issue-105084.rs",
+"ui/generator/issue-110929-generator-conflict-error-ice.rs",
+"ui/generator/issue-45729-unsafe-in-generator.rs",
+"ui/generator/issue-52304.rs",
+"ui/generator/issue-53548-1.rs",
+"ui/generator/issue-53548.rs",
+"ui/generator/issue-57017.rs",
+"ui/generator/issue-57084.rs",
+"ui/generator/issue-57478.rs",
+"ui/generator/issue-58888.rs",
+"ui/generator/issue-61442-stmt-expr-with-drop.rs",
+"ui/generator/issue-62506-two_awaits.rs",
+"ui/generator/issue-68112.rs",
+"ui/generator/issue-69017.rs",
+"ui/generator/issue-87142.rs",
+"ui/generator/issue-93161.rs",
+"ui/generic-associated-types/bugs/issue-87735.rs",
+"ui/generic-associated-types/bugs/issue-87755.rs",
+"ui/generic-associated-types/bugs/issue-87803.rs",
+"ui/generic-associated-types/bugs/issue-88382.rs",
+"ui/generic-associated-types/bugs/issue-88460.rs",
+"ui/generic-associated-types/bugs/issue-88526.rs",
+"ui/generic-associated-types/bugs/issue-91762.rs",
+"ui/generic-associated-types/bugs/issue-100013.rs",
+"ui/generic-associated-types/bugs/issue-80626.rs",
+"ui/generic-associated-types/issue-101020.rs",
+"ui/generic-associated-types/issue-102114.rs",
+"ui/generic-associated-types/issue-102335-gat.rs",
+"ui/generic-associated-types/issue-47206-where-clause.rs",
+"ui/generic-associated-types/issue-67510.rs",
+"ui/generic-associated-types/issue-68641-check-gat-bounds.rs",
+"ui/generic-associated-types/issue-68642-broken-llvm-ir.rs",
+"ui/generic-associated-types/issue-68643-broken-mir.rs",
+"ui/generic-associated-types/issue-68644-codegen-selection.rs",
+"ui/generic-associated-types/issue-68645-codegen-fulfillment.rs",
+"ui/generic-associated-types/issue-68648-2.rs",
+"ui/generic-associated-types/issue-68656-unsized-values.rs",
+"ui/generic-associated-types/issue-70304.rs",
+"ui/generic-associated-types/issue-71176.rs",
+"ui/generic-associated-types/issue-74684-1.rs",
+"ui/generic-associated-types/issue-74684-2.rs",
+"ui/generic-associated-types/issue-74816.rs",
+"ui/generic-associated-types/issue-74824.rs",
+"ui/generic-associated-types/issue-76826.rs",
+"ui/generic-associated-types/issue-78113-lifetime-mismatch-dyn-trait-box.rs",
+"ui/generic-associated-types/issue-79636-1.rs",
+"ui/generic-associated-types/issue-79636-2.rs",
+"ui/generic-associated-types/issue-80433.rs",
+"ui/generic-associated-types/issue-81487.rs",
+"ui/generic-associated-types/issue-81712-cyclic-traits.rs",
+"ui/generic-associated-types/issue-81862.rs",
+"ui/generic-associated-types/issue-84931.rs",
+"ui/generic-associated-types/issue-86787.rs",
+"ui/generic-associated-types/issue-87258_a.rs",
+"ui/generic-associated-types/issue-87258_b.rs",
+"ui/generic-associated-types/issue-87429-associated-type-default.rs",
+"ui/generic-associated-types/issue-87429-specialization.rs",
+"ui/generic-associated-types/issue-91139.rs",
+"ui/generic-associated-types/issue-91883.rs",
+"ui/generic-associated-types/issue-92033.rs",
+"ui/generic-associated-types/issue-95305.rs",
+"ui/generic-associated-types/issue-102333.rs",
+"ui/generic-associated-types/issue-58694-parameter-out-of-range.rs",
+"ui/generic-associated-types/issue-62326-parameter-out-of-range.rs",
+"ui/generic-associated-types/issue-67424.rs",
+"ui/generic-associated-types/issue-67510-pass.rs",
+"ui/generic-associated-types/issue-68648-1.rs",
+"ui/generic-associated-types/issue-68649-pass.rs",
+"ui/generic-associated-types/issue-68653.rs",
+"ui/generic-associated-types/issue-70303.rs",
+"ui/generic-associated-types/issue-76407.rs",
+"ui/generic-associated-types/issue-76535.rs",
+"ui/generic-associated-types/issue-78671.rs",
+"ui/generic-associated-types/issue-79422.rs",
+"ui/generic-associated-types/issue-80433-reduced.rs",
+"ui/generic-associated-types/issue-85921.rs",
+"ui/generic-associated-types/issue-86218-2.rs",
+"ui/generic-associated-types/issue-86218.rs",
+"ui/generic-associated-types/issue-86483.rs",
+"ui/generic-associated-types/issue-87429-2.rs",
+"ui/generic-associated-types/issue-87429.rs",
+"ui/generic-associated-types/issue-87748.rs",
+"ui/generic-associated-types/issue-87750.rs",
+"ui/generic-associated-types/issue-88287.rs",
+"ui/generic-associated-types/issue-88360.rs",
+"ui/generic-associated-types/issue-88405.rs",
+"ui/generic-associated-types/issue-88459.rs",
+"ui/generic-associated-types/issue-89008.rs",
+"ui/generic-associated-types/issue-89352.rs",
+"ui/generic-associated-types/issue-90014.rs",
+"ui/generic-associated-types/issue-90729.rs",
+"ui/generic-associated-types/issue-92096.rs",
+"ui/generic-associated-types/issue-92280.rs",
+"ui/generic-associated-types/issue-92954.rs",
+"ui/generic-associated-types/issue-93141.rs",
+"ui/generic-associated-types/issue-93262.rs",
+"ui/generic-associated-types/issue-93340.rs",
+"ui/generic-associated-types/issue-93341.rs",
+"ui/generic-associated-types/issue-93342.rs",
+"ui/generic-associated-types/issue-93874.rs",
+"ui/generic-associated-types/issue-88595.rs",
+"ui/generic-associated-types/issue-90014-tait.rs",
+"ui/generic-associated-types/issue-90014-tait2.rs",
+"ui/generics/issue-106694.rs",
+"ui/generics/issue-1112.rs",
+"ui/generics/issue-2936.rs",
+"ui/generics/issue-32498.rs",
+"ui/generics/issue-333.rs",
+"ui/generics/issue-59508-1.rs",
+"ui/generics/issue-61631-default-type-param-can-reference-self-in-trait.rs",
+"ui/generics/issue-61631-default-type-param-cannot-reference-self.rs",
+"ui/generics/issue-65285-incorrect-explicit-lifetime-name-needed.rs",
+"ui/generics/issue-79605.rs",
+"ui/generics/issue-80512-param-reordering-with-defaults.rs",
+"ui/generics/issue-94432-garbage-ice.rs",
+"ui/generics/issue-98432.rs",
+"ui/generics/issue-59508.rs",
+"ui/generics/issue-94923.rs",
+"ui/generics/issue-95208-ignore-qself.rs",
+"ui/generics/issue-95208.rs",
+"ui/hygiene/issue-15221.rs",
+"ui/hygiene/issue-40847.rs",
+"ui/hygiene/issue-77523-def-site-async-await.rs",
+"ui/hygiene/issue-32922.rs",
+"ui/hygiene/issue-44128.rs",
+"ui/hygiene/issue-47311.rs",
+"ui/hygiene/issue-47312.rs",
+"ui/hygiene/issue-61574-const-parameters.rs",
+"ui/impl-trait/explicit-generic-args-with-impl-trait/issue-87718.rs",
+"ui/impl-trait/in-trait/issue-102140.rs",
+"ui/impl-trait/in-trait/issue-102301.rs",
+"ui/impl-trait/in-trait/issue-102571.rs",
+"ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.rs",
+"ui/impl-trait/issues/issue-54600.rs",
+"ui/impl-trait/issues/issue-54840.rs",
+"ui/impl-trait/issues/issue-54895.rs",
+"ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.rs",
+"ui/impl-trait/issues/issue-57979-impl-trait-in-path.rs",
+"ui/impl-trait/issues/issue-57979-nested-impl-trait-in-assoc-proj.rs",
+"ui/impl-trait/issues/issue-58504.rs",
+"ui/impl-trait/issues/issue-58956.rs",
+"ui/impl-trait/issues/issue-62742.rs",
+"ui/impl-trait/issues/issue-67830.rs",
+"ui/impl-trait/issues/issue-70971.rs",
+"ui/impl-trait/issues/issue-79099.rs",
+"ui/impl-trait/issues/issue-82139.rs",
+"ui/impl-trait/issues/issue-83929-impl-trait-in-generic-default.rs",
+"ui/impl-trait/issues/issue-84073.rs",
+"ui/impl-trait/issues/issue-84919.rs",
+"ui/impl-trait/issues/issue-86642.rs",
+"ui/impl-trait/issues/issue-86719.rs",
+"ui/impl-trait/issues/issue-87295.rs",
+"ui/impl-trait/issues/issue-87340.rs",
+"ui/impl-trait/issues/issue-88236-2.rs",
+"ui/impl-trait/issues/issue-88236.rs",
+"ui/impl-trait/issues/issue-99348-impl-compatibility.rs",
+"ui/impl-trait/issues/issue-104815.rs",
+"ui/impl-trait/issues/issue-105826.rs",
+"ui/impl-trait/issues/issue-42479.rs",
+"ui/impl-trait/issues/issue-49376.rs",
+"ui/impl-trait/issues/issue-52128.rs",
+"ui/impl-trait/issues/issue-53457.rs",
+"ui/impl-trait/issues/issue-55608-captures-empty-region.rs",
+"ui/impl-trait/issues/issue-57464-unexpected-regions.rs",
+"ui/impl-trait/issues/issue-77987.rs",
+"ui/impl-trait/issues/issue-83919.rs",
+"ui/impl-trait/issues/issue-86201.rs",
+"ui/impl-trait/issues/issue-86800.rs",
+"ui/impl-trait/issues/issue-89312.rs",
+"ui/impl-trait/issues/issue-92305.rs",
+"ui/impl-trait/issues/issue-93788.rs",
+"ui/impl-trait/issues/issue-65581.rs",
+"ui/impl-trait/issues/issue-70877.rs",
+"ui/impl-trait/issues/issue-74282.rs",
+"ui/impl-trait/issues/issue-78722-2.rs",
+"ui/impl-trait/issues/issue-78722.rs",
+"ui/impl-trait/issue-100075-2.rs",
+"ui/impl-trait/issue-100075.rs",
+"ui/impl-trait/issue-35668.rs",
+"ui/impl-trait/issue-36792.rs",
+"ui/impl-trait/issue-49685.rs",
+"ui/impl-trait/issue-51185.rs",
+"ui/impl-trait/issue-54966.rs",
+"ui/impl-trait/issue-55872-1.rs",
+"ui/impl-trait/issue-55872.rs",
+"ui/impl-trait/issue-72911.rs",
+"ui/impl-trait/issue-86465.rs",
+"ui/impl-trait/issue-87450.rs",
+"ui/impl-trait/issue-99073-2.rs",
+"ui/impl-trait/issue-99073.rs",
+"ui/impl-trait/issue-100187.rs",
+"ui/impl-trait/issue-102605.rs",
+"ui/impl-trait/issue-103181-1.rs",
+"ui/impl-trait/issue-103599.rs",
+"ui/impl-trait/issue-108591.rs",
+"ui/impl-trait/issue-108592.rs",
+"ui/impl-trait/issue-46959.rs",
+"ui/impl-trait/issue-49556.rs",
+"ui/impl-trait/issue-49579.rs",
+"ui/impl-trait/issue-55872-2.rs",
+"ui/impl-trait/issue-56445.rs",
+"ui/impl-trait/issue-68532.rs",
+"ui/impl-trait/issue-99642-2.rs",
+"ui/impl-trait/issue-99642.rs",
+"ui/impl-trait/issue-99914.rs",
+"ui/impl-trait/issue-103181-2.rs",
+"ui/impl-trait/issue-55872-3.rs",
+"ui/implied-bounds/issue-100690.rs",
+"ui/implied-bounds/issue-101951.rs",
+"ui/implied-bounds/issue-110161.rs",
+"ui/imports/auxiliary/issue-36881-aux.rs",
+"ui/imports/auxiliary/issue-52891.rs",
+"ui/imports/auxiliary/issue-55811.rs",
+"ui/imports/auxiliary/issue-56125.rs",
+"ui/imports/auxiliary/issue-59764.rs",
+"ui/imports/auxiliary/issue-85992-extern-1.rs",
+"ui/imports/auxiliary/issue-85992-extern-2.rs",
+"ui/imports/issue-26873-multifile/issue-26873-multifile.rs",
+"ui/imports/issue-26873-multifile/issue-26873-onefile.rs",
+"ui/imports/issue-45829/auxiliary/issue-45829-a.rs",
+"ui/imports/issue-45829/auxiliary/issue-45829-b.rs",
+"ui/imports/issue-45829/issue-45829.rs",
+"ui/imports/issue-113953.rs",
+"ui/imports/issue-109343.rs",
+"ui/imports/issue-13404.rs",
+"ui/imports/issue-1697.rs",
+"ui/imports/issue-19498.rs",
+"ui/imports/issue-24081.rs",
+"ui/imports/issue-25396.rs",
+"ui/imports/issue-26886.rs",
+"ui/imports/issue-28388-1.rs",
+"ui/imports/issue-28388-2.rs",
+"ui/imports/issue-2937.rs",
+"ui/imports/issue-30560.rs",
+"ui/imports/issue-31212.rs",
+"ui/imports/issue-32833.rs",
+"ui/imports/issue-33464.rs",
+"ui/imports/issue-36881.rs",
+"ui/imports/issue-37887.rs",
+"ui/imports/issue-38293.rs",
+"ui/imports/issue-4366-2.rs",
+"ui/imports/issue-4366.rs",
+"ui/imports/issue-47623.rs",
+"ui/imports/issue-4865-1.rs",
+"ui/imports/issue-4865-2.rs",
+"ui/imports/issue-4865-3.rs",
+"ui/imports/issue-53269.rs",
+"ui/imports/issue-53512.rs",
+"ui/imports/issue-53565.rs",
+"ui/imports/issue-55457.rs",
+"ui/imports/issue-55884-1.rs",
+"ui/imports/issue-57015.rs",
+"ui/imports/issue-8208.rs",
+"ui/imports/issue-8640.rs",
+"ui/imports/issue-55884-2.rs",
+"ui/imports/issue-109148.rs",
+"ui/imports/issue-18083.rs",
+"ui/imports/issue-24883.rs",
+"ui/imports/issue-26930.rs",
+"ui/imports/issue-28134.rs",
+"ui/imports/issue-32119.rs",
+"ui/imports/issue-32222.rs",
+"ui/imports/issue-32354-suggest-import-rename.rs",
+"ui/imports/issue-45799-bad-extern-crate-rename-suggestion-formatting.rs",
+"ui/imports/issue-52891.rs",
+"ui/imports/issue-53140.rs",
+"ui/imports/issue-55811.rs",
+"ui/imports/issue-56125.rs",
+"ui/imports/issue-56263.rs",
+"ui/imports/issue-57539.rs",
+"ui/imports/issue-59764.rs",
+"ui/imports/issue-62767.rs",
+"ui/imports/issue-68103.rs",
+"ui/imports/issue-99695-b.rs",
+"ui/imports/issue-99695.rs",
+"ui/imports/issue-85992.rs",
+"ui/inference/need_type_info/issue-103053.rs",
+"ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.rs",
+"ui/inference/need_type_info/issue-109905.rs",
+"ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.rs",
+"ui/inference/issue-103587.rs",
+"ui/inference/issue-104649.rs",
+"ui/inference/issue-107090.rs",
+"ui/inference/issue-36053.rs",
+"ui/inference/issue-70082.rs",
+"ui/inference/issue-71309.rs",
+"ui/inference/issue-71584.rs",
+"ui/inference/issue-71732.rs",
+"ui/inference/issue-72616.rs",
+"ui/inference/issue-72690.rs",
+"ui/inference/issue-80816.rs",
+"ui/inference/issue-81522.rs",
+"ui/inference/issue-83606.rs",
+"ui/inference/issue-86162-1.rs",
+"ui/inference/issue-86162-2.rs",
+"ui/inference/issue-28935.rs",
+"ui/inference/issue-70703.rs",
+"ui/inference/issue-80409.rs",
+"ui/inference/issue-113354.rs",
+"ui/infinite/issue-41731-infinite-macro-print.rs",
+"ui/infinite/issue-41731-infinite-macro-println.rs",
+"ui/intrinsics/issue-28575.rs",
+"ui/intrinsics/issue-84297-reifying-copy.rs",
+"ui/issues/auxiliary/issue-11224.rs",
+"ui/issues/auxiliary/issue-11508.rs",
+"ui/issues/auxiliary/issue-11529.rs",
+"ui/issues/auxiliary/issue-11680.rs",
+"ui/issues/auxiliary/issue-12133-dylib.rs",
+"ui/issues/auxiliary/issue-12133-dylib2.rs",
+"ui/issues/auxiliary/issue-12133-rlib.rs",
+"ui/issues/auxiliary/issue-12612-1.rs",
+"ui/issues/auxiliary/issue-12612-2.rs",
+"ui/issues/auxiliary/issue-12660-aux.rs",
+"ui/issues/auxiliary/issue-13507.rs",
+"ui/issues/auxiliary/issue-13620-1.rs",
+"ui/issues/auxiliary/issue-13620-2.rs",
+"ui/issues/auxiliary/issue-13872-1.rs",
+"ui/issues/auxiliary/issue-13872-2.rs",
+"ui/issues/auxiliary/issue-13872-3.rs",
+"ui/issues/auxiliary/issue-14344-1.rs",
+"ui/issues/auxiliary/issue-14344-2.rs",
+"ui/issues/auxiliary/issue-14421.rs",
+"ui/issues/auxiliary/issue-14422.rs",
+"ui/issues/auxiliary/issue-15562.rs",
+"ui/issues/auxiliary/issue-16643.rs",
+"ui/issues/auxiliary/issue-16725.rs",
+"ui/issues/auxiliary/issue-17662.rs",
+"ui/issues/auxiliary/issue-18501.rs",
+"ui/issues/auxiliary/issue-18514.rs",
+"ui/issues/auxiliary/issue-18711.rs",
+"ui/issues/auxiliary/issue-18913-1.rs",
+"ui/issues/auxiliary/issue-18913-2.rs",
+"ui/issues/auxiliary/issue-1920.rs",
+"ui/issues/auxiliary/issue-19293.rs",
+"ui/issues/auxiliary/issue-19340-1.rs",
+"ui/issues/auxiliary/issue-20389.rs",
+"ui/issues/auxiliary/issue-21202.rs",
+"ui/issues/auxiliary/issue-2170-lib.rs",
+"ui/issues/auxiliary/issue-2316-a.rs",
+"ui/issues/auxiliary/issue-2316-b.rs",
+"ui/issues/auxiliary/issue-2380.rs",
+"ui/issues/auxiliary/issue-2414-a.rs",
+"ui/issues/auxiliary/issue-2414-b.rs",
+"ui/issues/auxiliary/issue-2472-b.rs",
+"ui/issues/auxiliary/issue-25185-1.rs",
+"ui/issues/auxiliary/issue-25185-2.rs",
+"ui/issues/auxiliary/issue-2526.rs",
+"ui/issues/auxiliary/issue-25467.rs",
+"ui/issues/auxiliary/issue-2631-a.rs",
+"ui/issues/auxiliary/issue-2723-a.rs",
+"ui/issues/auxiliary/issue-29181.rs",
+"ui/issues/auxiliary/issue-29265.rs",
+"ui/issues/auxiliary/issue-29485.rs",
+"ui/issues/auxiliary/issue-3012-1.rs",
+"ui/issues/auxiliary/issue-30123-aux.rs",
+"ui/issues/auxiliary/issue-3136-a.rs",
+"ui/issues/auxiliary/issue-31702-1.rs",
+"ui/issues/auxiliary/issue-34796-aux.rs",
+"ui/issues/auxiliary/issue-36954.rs",
+"ui/issues/auxiliary/issue-38190.rs",
+"ui/issues/auxiliary/issue-38226-aux.rs",
+"ui/issues/auxiliary/issue-3979-traits.rs",
+"ui/issues/auxiliary/issue-41053.rs",
+"ui/issues/auxiliary/issue-41549.rs",
+"ui/issues/auxiliary/issue-42007-s.rs",
+"ui/issues/auxiliary/issue-4208-cc.rs",
+"ui/issues/auxiliary/issue-4545.rs",
+"ui/issues/auxiliary/issue-48984-aux.rs",
+"ui/issues/auxiliary/issue-49544.rs",
+"ui/issues/auxiliary/issue-51798.rs",
+"ui/issues/auxiliary/issue-52489.rs",
+"ui/issues/auxiliary/issue-5518.rs",
+"ui/issues/auxiliary/issue-5521.rs",
+"ui/issues/auxiliary/issue-56943.rs",
+"ui/issues/auxiliary/issue-57271-lib.rs",
+"ui/issues/auxiliary/issue-5844-aux.rs",
+"ui/issues/auxiliary/issue-7178.rs",
+"ui/issues/auxiliary/issue-73112.rs",
+"ui/issues/auxiliary/issue-7899.rs",
+"ui/issues/auxiliary/issue-8044.rs",
+"ui/issues/auxiliary/issue-8259.rs",
+"ui/issues/auxiliary/issue-8401.rs",
+"ui/issues/auxiliary/issue-9123.rs",
+"ui/issues/auxiliary/issue-9155.rs",
+"ui/issues/auxiliary/issue-9188.rs",
+"ui/issues/auxiliary/issue-9906.rs",
+"ui/issues/auxiliary/issue-9968.rs",
+"ui/issues/auxiliary/issue-111011.rs",
+"ui/issues/auxiliary/issue-31702-2.rs",
+"ui/issues/issue-24687-embed-debuginfo/auxiliary/issue-24687-lib.rs",
+"ui/issues/issue-24687-embed-debuginfo/auxiliary/issue-24687-mbcs-in-comments.rs",
+"ui/issues/issue-37311-type-length-limit/issue-37311.rs",
+"ui/issues/issue-38875/auxiliary/issue-38875-b.rs",
+"ui/issues/issue-38875/issue-38875.rs",
+"ui/issues/issue-40402-ref-hints/issue-40402-1.rs",
+"ui/issues/issue-40402-ref-hints/issue-40402-2.rs",
+"ui/issues/issue-41652/auxiliary/issue-41652-b.rs",
+"ui/issues/issue-41652/issue-41652.rs",
+"ui/issues/issue-70093/issue-70093-link-directives.rs",
+"ui/issues/issue-70093/issue-70093.rs",
+"ui/issues/issue-77218/issue-77218-2.rs",
+"ui/issues/issue-77218/issue-77218.rs",
+"ui/issues/issue-100605.rs",
+"ui/issues/issue-10228.rs",
+"ui/issues/issue-10291.rs",
+"ui/issues/issue-102964.rs",
+"ui/issues/issue-10412.rs",
+"ui/issues/issue-10436.rs",
+"ui/issues/issue-10465.rs",
+"ui/issues/issue-10545.rs",
+"ui/issues/issue-10638.rs",
+"ui/issues/issue-10656.rs",
+"ui/issues/issue-10682.rs",
+"ui/issues/issue-10683.rs",
+"ui/issues/issue-10718.rs",
+"ui/issues/issue-10734.rs",
+"ui/issues/issue-10764.rs",
+"ui/issues/issue-10767.rs",
+"ui/issues/issue-10802.rs",
+"ui/issues/issue-10806.rs",
+"ui/issues/issue-10877.rs",
+"ui/issues/issue-11004.rs",
+"ui/issues/issue-11192.rs",
+"ui/issues/issue-11205.rs",
+"ui/issues/issue-11224.rs",
+"ui/issues/issue-11267.rs",
+"ui/issues/issue-11374.rs",
+"ui/issues/issue-11382.rs",
+"ui/issues/issue-11508.rs",
+"ui/issues/issue-11529.rs",
+"ui/issues/issue-11552.rs",
+"ui/issues/issue-11593.rs",
+"ui/issues/issue-11677.rs",
+"ui/issues/issue-11680.rs",
+"ui/issues/issue-11681.rs",
+"ui/issues/issue-11692-1.rs",
+"ui/issues/issue-11692-2.rs",
+"ui/issues/issue-11771.rs",
+"ui/issues/issue-11820.rs",
+"ui/issues/issue-11844.rs",
+"ui/issues/issue-11873.rs",
+"ui/issues/issue-11958.rs",
+"ui/issues/issue-12028.rs",
+"ui/issues/issue-12033.rs",
+"ui/issues/issue-12041.rs",
+"ui/issues/issue-12127.rs",
+"ui/issues/issue-12133-1.rs",
+"ui/issues/issue-12133-2.rs",
+"ui/issues/issue-12187-1.rs",
+"ui/issues/issue-12187-2.rs",
+"ui/issues/issue-12285.rs",
+"ui/issues/issue-12567.rs",
+"ui/issues/issue-12612.rs",
+"ui/issues/issue-12660.rs",
+"ui/issues/issue-12677.rs",
+"ui/issues/issue-12699.rs",
+"ui/issues/issue-12744.rs",
+"ui/issues/issue-12860.rs",
+"ui/issues/issue-12863.rs",
+"ui/issues/issue-12909.rs",
+"ui/issues/issue-13027.rs",
+"ui/issues/issue-13033.rs",
+"ui/issues/issue-13058.rs",
+"ui/issues/issue-13204.rs",
+"ui/issues/issue-13214.rs",
+"ui/issues/issue-13259-windows-tcb-trash.rs",
+"ui/issues/issue-13264.rs",
+"ui/issues/issue-13323.rs",
+"ui/issues/issue-13359.rs",
+"ui/issues/issue-13407.rs",
+"ui/issues/issue-13434.rs",
+"ui/issues/issue-13446.rs",
+"ui/issues/issue-13466.rs",
+"ui/issues/issue-13482.rs",
+"ui/issues/issue-13497-2.rs",
+"ui/issues/issue-13497.rs",
+"ui/issues/issue-13507-2.rs",
+"ui/issues/issue-1362.rs",
+"ui/issues/issue-13620.rs",
+"ui/issues/issue-13665.rs",
+"ui/issues/issue-13763.rs",
+"ui/issues/issue-13808.rs",
+"ui/issues/issue-13847.rs",
+"ui/issues/issue-13867.rs",
+"ui/issues/issue-13872.rs",
+"ui/issues/issue-14091-2.rs",
+"ui/issues/issue-14091.rs",
+"ui/issues/issue-14092.rs",
+"ui/issues/issue-14229.rs",
+"ui/issues/issue-14285.rs",
+"ui/issues/issue-14308.rs",
+"ui/issues/issue-14344.rs",
+"ui/issues/issue-14366.rs",
+"ui/issues/issue-14382.rs",
+"ui/issues/issue-14393.rs",
+"ui/issues/issue-14399.rs",
+"ui/issues/issue-14421.rs",
+"ui/issues/issue-14422.rs",
+"ui/issues/issue-1448-2.rs",
+"ui/issues/issue-1451.rs",
+"ui/issues/issue-14541.rs",
+"ui/issues/issue-1460.rs",
+"ui/issues/issue-14721.rs",
+"ui/issues/issue-1476.rs",
+"ui/issues/issue-14821.rs",
+"ui/issues/issue-14845.rs",
+"ui/issues/issue-14853.rs",
+"ui/issues/issue-14865.rs",
+"ui/issues/issue-14875.rs",
+"ui/issues/issue-14915.rs",
+"ui/issues/issue-14919.rs",
+"ui/issues/issue-15034.rs",
+"ui/issues/issue-15043.rs",
+"ui/issues/issue-15063.rs",
+"ui/issues/issue-15094.rs",
+"ui/issues/issue-15104.rs",
+"ui/issues/issue-15129-rpass.rs",
+"ui/issues/issue-15155.rs",
+"ui/issues/issue-15167.rs",
+"ui/issues/issue-15189.rs",
+"ui/issues/issue-15207.rs",
+"ui/issues/issue-15260.rs",
+"ui/issues/issue-15381.rs",
+"ui/issues/issue-15444.rs",
+"ui/issues/issue-15523-big.rs",
+"ui/issues/issue-15523.rs",
+"ui/issues/issue-15562.rs",
+"ui/issues/issue-15571.rs",
+"ui/issues/issue-15673.rs",
+"ui/issues/issue-15756.rs",
+"ui/issues/issue-15763.rs",
+"ui/issues/issue-15774.rs",
+"ui/issues/issue-15783.rs",
+"ui/issues/issue-15793.rs",
+"ui/issues/issue-15858.rs",
+"ui/issues/issue-15896.rs",
+"ui/issues/issue-15965.rs",
+"ui/issues/issue-16048.rs",
+"ui/issues/issue-16149.rs",
+"ui/issues/issue-16151.rs",
+"ui/issues/issue-16250.rs",
+"ui/issues/issue-16256.rs",
+"ui/issues/issue-16278.rs",
+"ui/issues/issue-16338.rs",
+"ui/issues/issue-16401.rs",
+"ui/issues/issue-16441.rs",
+"ui/issues/issue-16452.rs",
+"ui/issues/issue-16492.rs",
+"ui/issues/issue-16530.rs",
+"ui/issues/issue-16560.rs",
+"ui/issues/issue-16562.rs",
+"ui/issues/issue-1660.rs",
+"ui/issues/issue-16643.rs",
+"ui/issues/issue-16648.rs",
+"ui/issues/issue-16671.rs",
+"ui/issues/issue-16683.rs",
+"ui/issues/issue-16725.rs",
+"ui/issues/issue-16739.rs",
+"ui/issues/issue-16745.rs",
+"ui/issues/issue-16774.rs",
+"ui/issues/issue-16783.rs",
+"ui/issues/issue-16819.rs",
+"ui/issues/issue-16922-rpass.rs",
+"ui/issues/issue-16922.rs",
+"ui/issues/issue-16939.rs",
+"ui/issues/issue-1696.rs",
+"ui/issues/issue-16966.rs",
+"ui/issues/issue-17001.rs",
+"ui/issues/issue-17033.rs",
+"ui/issues/issue-17068.rs",
+"ui/issues/issue-17216.rs",
+"ui/issues/issue-17252.rs",
+"ui/issues/issue-17302.rs",
+"ui/issues/issue-17322.rs",
+"ui/issues/issue-17336.rs",
+"ui/issues/issue-17337.rs",
+"ui/issues/issue-17351.rs",
+"ui/issues/issue-17361.rs",
+"ui/issues/issue-17373.rs",
+"ui/issues/issue-17385.rs",
+"ui/issues/issue-17405.rs",
+"ui/issues/issue-17431-1.rs",
+"ui/issues/issue-17431-2.rs",
+"ui/issues/issue-17431-3.rs",
+"ui/issues/issue-17431-4.rs",
+"ui/issues/issue-17431-5.rs",
+"ui/issues/issue-17431-6.rs",
+"ui/issues/issue-17431-7.rs",
+"ui/issues/issue-17441.rs",
+"ui/issues/issue-17450.rs",
+"ui/issues/issue-17503.rs",
+"ui/issues/issue-17546.rs",
+"ui/issues/issue-17551.rs",
+"ui/issues/issue-17651.rs",
+"ui/issues/issue-17662.rs",
+"ui/issues/issue-17734.rs",
+"ui/issues/issue-17740.rs",
+"ui/issues/issue-17758.rs",
+"ui/issues/issue-17771.rs",
+"ui/issues/issue-17800.rs",
+"ui/issues/issue-17816.rs",
+"ui/issues/issue-17877.rs",
+"ui/issues/issue-17897.rs",
+"ui/issues/issue-17904-2.rs",
+"ui/issues/issue-17905-2.rs",
+"ui/issues/issue-17905.rs",
+"ui/issues/issue-17933.rs",
+"ui/issues/issue-17954.rs",
+"ui/issues/issue-17959.rs",
+"ui/issues/issue-17994.rs",
+"ui/issues/issue-17999.rs",
+"ui/issues/issue-18058.rs",
+"ui/issues/issue-18107.rs",
+"ui/issues/issue-18110.rs",
+"ui/issues/issue-18119.rs",
+"ui/issues/issue-18159.rs",
+"ui/issues/issue-18173.rs",
+"ui/issues/issue-18183.rs",
+"ui/issues/issue-18232.rs",
+"ui/issues/issue-18352.rs",
+"ui/issues/issue-18353.rs",
+"ui/issues/issue-18423.rs",
+"ui/issues/issue-18446.rs",
+"ui/issues/issue-18464.rs",
+"ui/issues/issue-18501.rs",
+"ui/issues/issue-18514.rs",
+"ui/issues/issue-18532.rs",
+"ui/issues/issue-18539.rs",
+"ui/issues/issue-18566.rs",
+"ui/issues/issue-18611.rs",
+"ui/issues/issue-18685.rs",
+"ui/issues/issue-18711.rs",
+"ui/issues/issue-18767.rs",
+"ui/issues/issue-18783.rs",
+"ui/issues/issue-18819.rs",
+"ui/issues/issue-18845.rs",
+"ui/issues/issue-18859.rs",
+"ui/issues/issue-18913.rs",
+"ui/issues/issue-18919.rs",
+"ui/issues/issue-18952.rs",
+"ui/issues/issue-18959.rs",
+"ui/issues/issue-1900.rs",
+"ui/issues/issue-19001.rs",
+"ui/issues/issue-19086.rs",
+"ui/issues/issue-19127.rs",
+"ui/issues/issue-19135.rs",
+"ui/issues/issue-1920-1.rs",
+"ui/issues/issue-1920-2.rs",
+"ui/issues/issue-1920-3.rs",
+"ui/issues/issue-19244-1.rs",
+"ui/issues/issue-19244-2.rs",
+"ui/issues/issue-19293.rs",
+"ui/issues/issue-19340-1.rs",
+"ui/issues/issue-19340-2.rs",
+"ui/issues/issue-19367.rs",
+"ui/issues/issue-19380.rs",
+"ui/issues/issue-19404.rs",
+"ui/issues/issue-19482.rs",
+"ui/issues/issue-19499.rs",
+"ui/issues/issue-19521.rs",
+"ui/issues/issue-19692.rs",
+"ui/issues/issue-19707.rs",
+"ui/issues/issue-19734.rs",
+"ui/issues/issue-1974.rs",
+"ui/issues/issue-19811-escape-unicode.rs",
+"ui/issues/issue-19922.rs",
+"ui/issues/issue-19991.rs",
+"ui/issues/issue-20055-box-trait.rs",
+"ui/issues/issue-20055-box-unsized-array.rs",
+"ui/issues/issue-20162.rs",
+"ui/issues/issue-20174.rs",
+"ui/issues/issue-20225.rs",
+"ui/issues/issue-20261.rs",
+"ui/issues/issue-20313-rpass.rs",
+"ui/issues/issue-20313.rs",
+"ui/issues/issue-20389.rs",
+"ui/issues/issue-20413.rs",
+"ui/issues/issue-20427.rs",
+"ui/issues/issue-20433.rs",
+"ui/issues/issue-20544.rs",
+"ui/issues/issue-20575.rs",
+"ui/issues/issue-20616.rs",
+"ui/issues/issue-20676.rs",
+"ui/issues/issue-20714.rs",
+"ui/issues/issue-2074.rs",
+"ui/issues/issue-20772.rs",
+"ui/issues/issue-20797.rs",
+"ui/issues/issue-20803.rs",
+"ui/issues/issue-20831-debruijn.rs",
+"ui/issues/issue-20847.rs",
+"ui/issues/issue-20939.rs",
+"ui/issues/issue-20953.rs",
+"ui/issues/issue-21033.rs",
+"ui/issues/issue-21160.rs",
+"ui/issues/issue-21174.rs",
+"ui/issues/issue-21177.rs",
+"ui/issues/issue-21202.rs",
+"ui/issues/issue-21291.rs",
+"ui/issues/issue-21306.rs",
+"ui/issues/issue-21332.rs",
+"ui/issues/issue-21361.rs",
+"ui/issues/issue-21384.rs",
+"ui/issues/issue-21400.rs",
+"ui/issues/issue-21449.rs",
+"ui/issues/issue-2150.rs",
+"ui/issues/issue-2151.rs",
+"ui/issues/issue-21546.rs",
+"ui/issues/issue-21554.rs",
+"ui/issues/issue-21596.rs",
+"ui/issues/issue-21600.rs",
+"ui/issues/issue-21634.rs",
+"ui/issues/issue-21655.rs",
+"ui/issues/issue-2170-exe.rs",
+"ui/issues/issue-21701.rs",
+"ui/issues/issue-21763.rs",
+"ui/issues/issue-21837.rs",
+"ui/issues/issue-21891.rs",
+"ui/issues/issue-2190-1.rs",
+"ui/issues/issue-21909.rs",
+"ui/issues/issue-21922.rs",
+"ui/issues/issue-21946.rs",
+"ui/issues/issue-21950.rs",
+"ui/issues/issue-21974.rs",
+"ui/issues/issue-22008.rs",
+"ui/issues/issue-22034.rs",
+"ui/issues/issue-22036.rs",
+"ui/issues/issue-2214.rs",
+"ui/issues/issue-22258.rs",
+"ui/issues/issue-22289.rs",
+"ui/issues/issue-22312.rs",
+"ui/issues/issue-22346.rs",
+"ui/issues/issue-22370.rs",
+"ui/issues/issue-22403.rs",
+"ui/issues/issue-22426.rs",
+"ui/issues/issue-22434.rs",
+"ui/issues/issue-22468.rs",
+"ui/issues/issue-22577.rs",
+"ui/issues/issue-22599.rs",
+"ui/issues/issue-22629.rs",
+"ui/issues/issue-22638.rs",
+"ui/issues/issue-22644.rs",
+"ui/issues/issue-22684.rs",
+"ui/issues/issue-22706.rs",
+"ui/issues/issue-2281-part1.rs",
+"ui/issues/issue-2284.rs",
+"ui/issues/issue-22864-1.rs",
+"ui/issues/issue-22864-2.rs",
+"ui/issues/issue-22872.rs",
+"ui/issues/issue-22874.rs",
+"ui/issues/issue-2288.rs",
+"ui/issues/issue-22886.rs",
+"ui/issues/issue-22894.rs",
+"ui/issues/issue-22933-2.rs",
+"ui/issues/issue-22992-2.rs",
+"ui/issues/issue-22992.rs",
+"ui/issues/issue-23024.rs",
+"ui/issues/issue-23036.rs",
+"ui/issues/issue-23041.rs",
+"ui/issues/issue-23046.rs",
+"ui/issues/issue-23073.rs",
+"ui/issues/issue-23122-1.rs",
+"ui/issues/issue-23122-2.rs",
+"ui/issues/issue-2316-c.rs",
+"ui/issues/issue-23173.rs",
+"ui/issues/issue-23189.rs",
+"ui/issues/issue-23217.rs",
+"ui/issues/issue-23253.rs",
+"ui/issues/issue-23261.rs",
+"ui/issues/issue-23281.rs",
+"ui/issues/issue-23302-1.rs",
+"ui/issues/issue-23302-2.rs",
+"ui/issues/issue-23302-3.rs",
+"ui/issues/issue-23304-1.rs",
+"ui/issues/issue-23304-2.rs",
+"ui/issues/issue-23311.rs",
+"ui/issues/issue-23336.rs",
+"ui/issues/issue-23406.rs",
+"ui/issues/issue-23433.rs",
+"ui/issues/issue-23485.rs",
+"ui/issues/issue-23491.rs",
+"ui/issues/issue-23543.rs",
+"ui/issues/issue-23544.rs",
+"ui/issues/issue-23550.rs",
+"ui/issues/issue-23589.rs",
+"ui/issues/issue-23611-enum-swap-in-drop.rs",
+"ui/issues/issue-23649-1.rs",
+"ui/issues/issue-23649-2.rs",
+"ui/issues/issue-23649-3.rs",
+"ui/issues/issue-23699.rs",
+"ui/issues/issue-23781.rs",
+"ui/issues/issue-2380-b.rs",
+"ui/issues/issue-2383.rs",
+"ui/issues/issue-23891.rs",
+"ui/issues/issue-23898.rs",
+"ui/issues/issue-23958.rs",
+"ui/issues/issue-23966.rs",
+"ui/issues/issue-23992.rs",
+"ui/issues/issue-24013.rs",
+"ui/issues/issue-24036.rs",
+"ui/issues/issue-24086.rs",
+"ui/issues/issue-2414-c.rs",
+"ui/issues/issue-2428.rs",
+"ui/issues/issue-24308.rs",
+"ui/issues/issue-24322.rs",
+"ui/issues/issue-24352.rs",
+"ui/issues/issue-24353.rs",
+"ui/issues/issue-24357.rs",
+"ui/issues/issue-24363.rs",
+"ui/issues/issue-24365.rs",
+"ui/issues/issue-24424.rs",
+"ui/issues/issue-24446.rs",
+"ui/issues/issue-2445-b.rs",
+"ui/issues/issue-2445.rs",
+"ui/issues/issue-24533.rs",
+"ui/issues/issue-24589.rs",
+"ui/issues/issue-2463.rs",
+"ui/issues/issue-24682.rs",
+"ui/issues/issue-2472.rs",
+"ui/issues/issue-24779.rs",
+"ui/issues/issue-24819.rs",
+"ui/issues/issue-2487-a.rs",
+"ui/issues/issue-24947.rs",
+"ui/issues/issue-24954.rs",
+"ui/issues/issue-25076.rs",
+"ui/issues/issue-25089.rs",
+"ui/issues/issue-25145.rs",
+"ui/issues/issue-25185.rs",
+"ui/issues/issue-2526-a.rs",
+"ui/issues/issue-25279.rs",
+"ui/issues/issue-25343.rs",
+"ui/issues/issue-25368.rs",
+"ui/issues/issue-25386.rs",
+"ui/issues/issue-25439.rs",
+"ui/issues/issue-25467.rs",
+"ui/issues/issue-25497.rs",
+"ui/issues/issue-2550.rs",
+"ui/issues/issue-25515.rs",
+"ui/issues/issue-25549-multiple-drop.rs",
+"ui/issues/issue-25679.rs",
+"ui/issues/issue-25693.rs",
+"ui/issues/issue-25746-bool-transmute.rs",
+"ui/issues/issue-25757.rs",
+"ui/issues/issue-25810.rs",
+"ui/issues/issue-2590.rs",
+"ui/issues/issue-25901.rs",
+"ui/issues/issue-26056.rs",
+"ui/issues/issue-26093.rs",
+"ui/issues/issue-26127.rs",
+"ui/issues/issue-26217.rs",
+"ui/issues/issue-26237.rs",
+"ui/issues/issue-26262.rs",
+"ui/issues/issue-2631-b.rs",
+"ui/issues/issue-2642.rs",
+"ui/issues/issue-26468.rs",
+"ui/issues/issue-26472.rs",
+"ui/issues/issue-26619.rs",
+"ui/issues/issue-26641.rs",
+"ui/issues/issue-26655.rs",
+"ui/issues/issue-26709.rs",
+"ui/issues/issue-26802.rs",
+"ui/issues/issue-26805.rs",
+"ui/issues/issue-26812.rs",
+"ui/issues/issue-26905-rpass.rs",
+"ui/issues/issue-26905.rs",
+"ui/issues/issue-26948.rs",
+"ui/issues/issue-27008.rs",
+"ui/issues/issue-27033.rs",
+"ui/issues/issue-27042.rs",
+"ui/issues/issue-27054-primitive-binary-ops.rs",
+"ui/issues/issue-27078.rs",
+"ui/issues/issue-2708.rs",
+"ui/issues/issue-2723-b.rs",
+"ui/issues/issue-27240.rs",
+"ui/issues/issue-27268.rs",
+"ui/issues/issue-27340.rs",
+"ui/issues/issue-27401-dropflag-reinit.rs",
+"ui/issues/issue-27592.rs",
+"ui/issues/issue-27639.rs",
+"ui/issues/issue-27815.rs",
+"ui/issues/issue-27842.rs",
+"ui/issues/issue-27859.rs",
+"ui/issues/issue-27942.rs",
+"ui/issues/issue-27949.rs",
+"ui/issues/issue-27997.rs",
+"ui/issues/issue-28105.rs",
+"ui/issues/issue-28109.rs",
+"ui/issues/issue-28181.rs",
+"ui/issues/issue-2823.rs",
+"ui/issues/issue-28344.rs",
+"ui/issues/issue-28433.rs",
+"ui/issues/issue-28472.rs",
+"ui/issues/issue-2848.rs",
+"ui/issues/issue-2849.rs",
+"ui/issues/issue-28498-must-work-ex1.rs",
+"ui/issues/issue-28498-must-work-ex2.rs",
+"ui/issues/issue-28498-ugeh-ex1.rs",
+"ui/issues/issue-28550.rs",
+"ui/issues/issue-28568.rs",
+"ui/issues/issue-28586.rs",
+"ui/issues/issue-28625.rs",
+"ui/issues/issue-28777.rs",
+"ui/issues/issue-28828.rs",
+"ui/issues/issue-28839.rs",
+"ui/issues/issue-2895.rs",
+"ui/issues/issue-28971.rs",
+"ui/issues/issue-28983.rs",
+"ui/issues/issue-28992-empty.rs",
+"ui/issues/issue-2904.rs",
+"ui/issues/issue-29053.rs",
+"ui/issues/issue-29071-2.rs",
+"ui/issues/issue-29092.rs",
+"ui/issues/issue-29147-rpass.rs",
+"ui/issues/issue-29147.rs",
+"ui/issues/issue-29181.rs",
+"ui/issues/issue-2935.rs",
+"ui/issues/issue-29466.rs",
+"ui/issues/issue-29485.rs",
+"ui/issues/issue-2951.rs",
+"ui/issues/issue-29522.rs",
+"ui/issues/issue-29540.rs",
+"ui/issues/issue-29663.rs",
+"ui/issues/issue-29668.rs",
+"ui/issues/issue-29723.rs",
+"ui/issues/issue-29746.rs",
+"ui/issues/issue-29821.rs",
+"ui/issues/issue-29861.rs",
+"ui/issues/issue-2989.rs",
+"ui/issues/issue-29948.rs",
+"ui/issues/issue-2995.rs",
+"ui/issues/issue-30007.rs",
+"ui/issues/issue-30018-panic.rs",
+"ui/issues/issue-30081.rs",
+"ui/issues/issue-3012-2.rs",
+"ui/issues/issue-30123.rs",
+"ui/issues/issue-3021-b.rs",
+"ui/issues/issue-3021-d.rs",
+"ui/issues/issue-30236.rs",
+"ui/issues/issue-30255.rs",
+"ui/issues/issue-3026.rs",
+"ui/issues/issue-3037.rs",
+"ui/issues/issue-30371.rs",
+"ui/issues/issue-3038.rs",
+"ui/issues/issue-30490.rs",
+"ui/issues/issue-3052.rs",
+"ui/issues/issue-30530.rs",
+"ui/issues/issue-30589.rs",
+"ui/issues/issue-30615.rs",
+"ui/issues/issue-30756.rs",
+"ui/issues/issue-30891.rs",
+"ui/issues/issue-3091.rs",
+"ui/issues/issue-31011.rs",
+"ui/issues/issue-3109.rs",
+"ui/issues/issue-3121.rs",
+"ui/issues/issue-31267-additional.rs",
+"ui/issues/issue-31267.rs",
+"ui/issues/issue-31299.rs",
+"ui/issues/issue-3136-b.rs",
+"ui/issues/issue-31511.rs",
+"ui/issues/issue-3154.rs",
+"ui/issues/issue-31702.rs",
+"ui/issues/issue-31769.rs",
+"ui/issues/issue-31776.rs",
+"ui/issues/issue-31910.rs",
+"ui/issues/issue-32004.rs",
+"ui/issues/issue-32008.rs",
+"ui/issues/issue-32086.rs",
+"ui/issues/issue-3214.rs",
+"ui/issues/issue-3220.rs",
+"ui/issues/issue-32292.rs",
+"ui/issues/issue-32323.rs",
+"ui/issues/issue-32326.rs",
+"ui/issues/issue-32377.rs",
+"ui/issues/issue-32389.rs",
+"ui/issues/issue-32518.rs",
+"ui/issues/issue-32655.rs",
+"ui/issues/issue-32709.rs",
+"ui/issues/issue-32782.rs",
+"ui/issues/issue-32805.rs",
+"ui/issues/issue-3290.rs",
+"ui/issues/issue-32950.rs",
+"ui/issues/issue-32995-2.rs",
+"ui/issues/issue-32995.rs",
+"ui/issues/issue-33187.rs",
+"ui/issues/issue-33202.rs",
+"ui/issues/issue-33287.rs",
+"ui/issues/issue-33293.rs",
+"ui/issues/issue-33387.rs",
+"ui/issues/issue-3344.rs",
+"ui/issues/issue-33461.rs",
+"ui/issues/issue-33504.rs",
+"ui/issues/issue-33525.rs",
+"ui/issues/issue-33571.rs",
+"ui/issues/issue-33687.rs",
+"ui/issues/issue-33770.rs",
+"ui/issues/issue-3389.rs",
+"ui/issues/issue-33992.rs",
+"ui/issues/issue-34047.rs",
+"ui/issues/issue-34074.rs",
+"ui/issues/issue-34209.rs",
+"ui/issues/issue-34229.rs",
+"ui/issues/issue-3429.rs",
+"ui/issues/issue-34334.rs",
+"ui/issues/issue-34349.rs",
+"ui/issues/issue-34373.rs",
+"ui/issues/issue-34427.rs",
+"ui/issues/issue-3447.rs",
+"ui/issues/issue-34503.rs",
+"ui/issues/issue-34571.rs",
+"ui/issues/issue-3477.rs",
+"ui/issues/issue-34796.rs",
+"ui/issues/issue-3500.rs",
+"ui/issues/issue-35139.rs",
+"ui/issues/issue-35241.rs",
+"ui/issues/issue-35423.rs",
+"ui/issues/issue-3556.rs",
+"ui/issues/issue-3559.rs",
+"ui/issues/issue-35600.rs",
+"ui/issues/issue-3563-3.rs",
+"ui/issues/issue-3574.rs",
+"ui/issues/issue-35815.rs",
+"ui/issues/issue-35988.rs",
+"ui/issues/issue-36023.rs",
+"ui/issues/issue-36036-associated-type-layout.rs",
+"ui/issues/issue-36260.rs",
+"ui/issues/issue-36278-prefix-nesting.rs",
+"ui/issues/issue-36299.rs",
+"ui/issues/issue-36400.rs",
+"ui/issues/issue-36401.rs",
+"ui/issues/issue-36474.rs",
+"ui/issues/issue-3668.rs",
+"ui/issues/issue-36744-bitcast-args-if-needed.rs",
+"ui/issues/issue-36786-resolve-call.rs",
+"ui/issues/issue-3680.rs",
+"ui/issues/issue-36816.rs",
+"ui/issues/issue-36836.rs",
+"ui/issues/issue-36936.rs",
+"ui/issues/issue-36954.rs",
+"ui/issues/issue-3702-2.rs",
+"ui/issues/issue-3702.rs",
+"ui/issues/issue-3707.rs",
+"ui/issues/issue-37109.rs",
+"ui/issues/issue-3743.rs",
+"ui/issues/issue-3753.rs",
+"ui/issues/issue-37534.rs",
+"ui/issues/issue-37576.rs",
+"ui/issues/issue-3763.rs",
+"ui/issues/issue-37686.rs",
+"ui/issues/issue-37725.rs",
+"ui/issues/issue-37733.rs",
+"ui/issues/issue-3779.rs",
+"ui/issues/issue-37884.rs",
+"ui/issues/issue-38190.rs",
+"ui/issues/issue-38412.rs",
+"ui/issues/issue-38437.rs",
+"ui/issues/issue-38458.rs",
+"ui/issues/issue-3847.rs",
+"ui/issues/issue-38556.rs",
+"ui/issues/issue-38727.rs",
+"ui/issues/issue-3874.rs",
+"ui/issues/issue-38763.rs",
+"ui/issues/issue-3878.rs",
+"ui/issues/issue-38857.rs",
+"ui/issues/issue-38919.rs",
+"ui/issues/issue-38942.rs",
+"ui/issues/issue-3895.rs",
+"ui/issues/issue-38954.rs",
+"ui/issues/issue-38987.rs",
+"ui/issues/issue-39175.rs",
+"ui/issues/issue-39211.rs",
+"ui/issues/issue-39548.rs",
+"ui/issues/issue-39687.rs",
+"ui/issues/issue-39709.rs",
+"ui/issues/issue-3979-generics.rs",
+"ui/issues/issue-3979-xcrate.rs",
+"ui/issues/issue-3979.rs",
+"ui/issues/issue-39808.rs",
+"ui/issues/issue-39827.rs",
+"ui/issues/issue-39848.rs",
+"ui/issues/issue-3993.rs",
+"ui/issues/issue-39970.rs",
+"ui/issues/issue-40000.rs",
+"ui/issues/issue-40085.rs",
+"ui/issues/issue-40235.rs",
+"ui/issues/issue-40288-2.rs",
+"ui/issues/issue-40288.rs",
+"ui/issues/issue-40408.rs",
+"ui/issues/issue-40510-1.rs",
+"ui/issues/issue-40510-3.rs",
+"ui/issues/issue-40610.rs",
+"ui/issues/issue-40749.rs",
+"ui/issues/issue-40827.rs",
+"ui/issues/issue-40845.rs",
+"ui/issues/issue-40861.rs",
+"ui/issues/issue-40883.rs",
+"ui/issues/issue-40951.rs",
+"ui/issues/issue-41053.rs",
+"ui/issues/issue-41139.rs",
+"ui/issues/issue-41213.rs",
+"ui/issues/issue-41229-ref-str.rs",
+"ui/issues/issue-41479.rs",
+"ui/issues/issue-41498.rs",
+"ui/issues/issue-41549.rs",
+"ui/issues/issue-41604.rs",
+"ui/issues/issue-41677.rs",
+"ui/issues/issue-41696.rs",
+"ui/issues/issue-41726.rs",
+"ui/issues/issue-41742.rs",
+"ui/issues/issue-41744.rs",
+"ui/issues/issue-41849-variance-req.rs",
+"ui/issues/issue-41880.rs",
+"ui/issues/issue-41888.rs",
+"ui/issues/issue-41974.rs",
+"ui/issues/issue-42007.rs",
+"ui/issues/issue-4208.rs",
+"ui/issues/issue-42106.rs",
+"ui/issues/issue-42148.rs",
+"ui/issues/issue-4228.rs",
+"ui/issues/issue-42312.rs",
+"ui/issues/issue-42453.rs",
+"ui/issues/issue-4252.rs",
+"ui/issues/issue-42552.rs",
+"ui/issues/issue-4265.rs",
+"ui/issues/issue-42755.rs",
+"ui/issues/issue-42796.rs",
+"ui/issues/issue-42880.rs",
+"ui/issues/issue-43162.rs",
+"ui/issues/issue-43205.rs",
+"ui/issues/issue-43250.rs",
+"ui/issues/issue-43291.rs",
+"ui/issues/issue-4333.rs",
+"ui/issues/issue-4335.rs",
+"ui/issues/issue-43355.rs",
+"ui/issues/issue-43420-no-over-suggest.rs",
+"ui/issues/issue-43424.rs",
+"ui/issues/issue-43431.rs",
+"ui/issues/issue-43692.rs",
+"ui/issues/issue-43853.rs",
+"ui/issues/issue-4387.rs",
+"ui/issues/issue-43910.rs",
+"ui/issues/issue-43923.rs",
+"ui/issues/issue-43925.rs",
+"ui/issues/issue-43926.rs",
+"ui/issues/issue-43988.rs",
+"ui/issues/issue-44023.rs",
+"ui/issues/issue-44078.rs",
+"ui/issues/issue-44255.rs",
+"ui/issues/issue-44405.rs",
+"ui/issues/issue-4517.rs",
+"ui/issues/issue-4541.rs",
+"ui/issues/issue-4542.rs",
+"ui/issues/issue-4545.rs",
+"ui/issues/issue-45510.rs",
+"ui/issues/issue-45730.rs",
+"ui/issues/issue-45801.rs",
+"ui/issues/issue-45965.rs",
+"ui/issues/issue-46069.rs",
+"ui/issues/issue-46101.rs",
+"ui/issues/issue-46302.rs",
+"ui/issues/issue-46311.rs",
+"ui/issues/issue-46332.rs",
+"ui/issues/issue-46438.rs",
+"ui/issues/issue-46471-1.rs",
+"ui/issues/issue-46472.rs",
+"ui/issues/issue-46604.rs",
+"ui/issues/issue-46771.rs",
+"ui/issues/issue-46983.rs",
+"ui/issues/issue-47073-zero-padded-tuple-struct-indices.rs",
+"ui/issues/issue-47094.rs",
+"ui/issues/issue-47184.rs",
+"ui/issues/issue-4734.rs",
+"ui/issues/issue-4735.rs",
+"ui/issues/issue-4736.rs",
+"ui/issues/issue-47377.rs",
+"ui/issues/issue-47380.rs",
+"ui/issues/issue-47486.rs",
+"ui/issues/issue-4759-1.rs",
+"ui/issues/issue-4759.rs",
+"ui/issues/issue-47638.rs",
+"ui/issues/issue-47715.rs",
+"ui/issues/issue-47725.rs",
+"ui/issues/issue-48006.rs",
+"ui/issues/issue-48132.rs",
+"ui/issues/issue-48159.rs",
+"ui/issues/issue-48276.rs",
+"ui/issues/issue-48364.rs",
+"ui/issues/issue-48728.rs",
+"ui/issues/issue-4875.rs",
+"ui/issues/issue-48838.rs",
+"ui/issues/issue-48984.rs",
+"ui/issues/issue-49298.rs",
+"ui/issues/issue-4935.rs",
+"ui/issues/issue-49632.rs",
+"ui/issues/issue-4968.rs",
+"ui/issues/issue-4972.rs",
+"ui/issues/issue-49824.rs",
+"ui/issues/issue-49854.rs",
+"ui/issues/issue-49919.rs",
+"ui/issues/issue-49934-errors.rs",
+"ui/issues/issue-49934.rs",
+"ui/issues/issue-49955.rs",
+"ui/issues/issue-49973.rs",
+"ui/issues/issue-5008-borrowed-traitobject-method-call.rs",
+"ui/issues/issue-50403.rs",
+"ui/issues/issue-50415.rs",
+"ui/issues/issue-50442.rs",
+"ui/issues/issue-50581.rs",
+"ui/issues/issue-50582.rs",
+"ui/issues/issue-50585.rs",
+"ui/issues/issue-50600.rs",
+"ui/issues/issue-50618.rs",
+"ui/issues/issue-5062.rs",
+"ui/issues/issue-50688.rs",
+"ui/issues/issue-50714-1.rs",
+"ui/issues/issue-50714.rs",
+"ui/issues/issue-50761.rs",
+"ui/issues/issue-50781.rs",
+"ui/issues/issue-50802.rs",
+"ui/issues/issue-5100.rs",
+"ui/issues/issue-51022.rs",
+"ui/issues/issue-51044.rs",
+"ui/issues/issue-51102.rs",
+"ui/issues/issue-51116.rs",
+"ui/issues/issue-51154.rs",
+"ui/issues/issue-51515.rs",
+"ui/issues/issue-5153.rs",
+"ui/issues/issue-51632-try-desugar-incompatible-types.rs",
+"ui/issues/issue-51874.rs",
+"ui/issues/issue-5192.rs",
+"ui/issues/issue-51947.rs",
+"ui/issues/issue-52049.rs",
+"ui/issues/issue-52126-assign-op-invariance.rs",
+"ui/issues/issue-52262.rs",
+"ui/issues/issue-5239-1.rs",
+"ui/issues/issue-5239-2.rs",
+"ui/issues/issue-52533.rs",
+"ui/issues/issue-52717.rs",
+"ui/issues/issue-5280.rs",
+"ui/issues/issue-5315.rs",
+"ui/issues/issue-5321-immediates-with-bare-self.rs",
+"ui/issues/issue-53251.rs",
+"ui/issues/issue-53275.rs",
+"ui/issues/issue-53300.rs",
+"ui/issues/issue-53348.rs",
+"ui/issues/issue-53498.rs",
+"ui/issues/issue-5358-1.rs",
+"ui/issues/issue-53728.rs",
+"ui/issues/issue-53843.rs",
+"ui/issues/issue-54044.rs",
+"ui/issues/issue-54062.rs",
+"ui/issues/issue-5439.rs",
+"ui/issues/issue-54410.rs",
+"ui/issues/issue-54477-reduced-2.rs",
+"ui/issues/issue-54696.rs",
+"ui/issues/issue-5518.rs",
+"ui/issues/issue-5521.rs",
+"ui/issues/issue-55376.rs",
+"ui/issues/issue-55380.rs",
+"ui/issues/issue-5550.rs",
+"ui/issues/issue-5554.rs",
+"ui/issues/issue-55587.rs",
+"ui/issues/issue-55731.rs",
+"ui/issues/issue-56199.rs",
+"ui/issues/issue-56237.rs",
+"ui/issues/issue-5666.rs",
+"ui/issues/issue-56806.rs",
+"ui/issues/issue-56835.rs",
+"ui/issues/issue-56870.rs",
+"ui/issues/issue-5688.rs",
+"ui/issues/issue-56943.rs",
+"ui/issues/issue-5708.rs",
+"ui/issues/issue-5718.rs",
+"ui/issues/issue-57198-pass.rs",
+"ui/issues/issue-57271.rs",
+"ui/issues/issue-57362-1.rs",
+"ui/issues/issue-57362-2.rs",
+"ui/issues/issue-5741.rs",
+"ui/issues/issue-57741-1.rs",
+"ui/issues/issue-57781.rs",
+"ui/issues/issue-57924.rs",
+"ui/issues/issue-58712.rs",
+"ui/issues/issue-58734.rs",
+"ui/issues/issue-5884.rs",
+"ui/issues/issue-58857.rs",
+"ui/issues/issue-5917.rs",
+"ui/issues/issue-59488.rs",
+"ui/issues/issue-59494.rs",
+"ui/issues/issue-5988.rs",
+"ui/issues/issue-5997-enum.rs",
+"ui/issues/issue-5997-struct.rs",
+"ui/issues/issue-5997.rs",
+"ui/issues/issue-60218.rs",
+"ui/issues/issue-60622.rs",
+"ui/issues/issue-60989.rs",
+"ui/issues/issue-61106.rs",
+"ui/issues/issue-61108.rs",
+"ui/issues/issue-6117.rs",
+"ui/issues/issue-6130.rs",
+"ui/issues/issue-61475.rs",
+"ui/issues/issue-6153.rs",
+"ui/issues/issue-61623.rs",
+"ui/issues/issue-61894.rs",
+"ui/issues/issue-62375.rs",
+"ui/issues/issue-62480.rs",
+"ui/issues/issue-6318.rs",
+"ui/issues/issue-6344-let.rs",
+"ui/issues/issue-6344-match.rs",
+"ui/issues/issue-63983.rs",
+"ui/issues/issue-64559.rs",
+"ui/issues/issue-64792-bad-unicode-ctor.rs",
+"ui/issues/issue-65131.rs",
+"ui/issues/issue-65230.rs",
+"ui/issues/issue-65462.rs",
+"ui/issues/issue-6596-2.rs",
+"ui/issues/issue-66353.rs",
+"ui/issues/issue-6642.rs",
+"ui/issues/issue-66667-function-cmp-cycle.rs",
+"ui/issues/issue-66702-break-outside-loop-val.rs",
+"ui/issues/issue-66706.rs",
+"ui/issues/issue-66923-show-error-for-correct-call.rs",
+"ui/issues/issue-67039-unsound-pin-partialeq.rs",
+"ui/issues/issue-6738.rs",
+"ui/issues/issue-67535.rs",
+"ui/issues/issue-68010-large-zst-consts.rs",
+"ui/issues/issue-68696-catch-during-unwind.rs",
+"ui/issues/issue-6892.rs",
+"ui/issues/issue-69130.rs",
+"ui/issues/issue-6919.rs",
+"ui/issues/issue-69306.rs",
+"ui/issues/issue-6936.rs",
+"ui/issues/issue-69455.rs",
+"ui/issues/issue-69602-type-err-during-codegen-ice.rs",
+"ui/issues/issue-69683.rs",
+"ui/issues/issue-7012.rs",
+"ui/issues/issue-70381.rs",
+"ui/issues/issue-7044.rs",
+"ui/issues/issue-7061.rs",
+"ui/issues/issue-70673.rs",
+"ui/issues/issue-70724-add_type_neq_err_label-unwrap.rs",
+"ui/issues/issue-7092.rs",
+"ui/issues/issue-71406.rs",
+"ui/issues/issue-71676-2.rs",
+"ui/issues/issue-7178.rs",
+"ui/issues/issue-72076.rs",
+"ui/issues/issue-72278.rs",
+"ui/issues/issue-7246.rs",
+"ui/issues/issue-72839-error-overflow.rs",
+"ui/issues/issue-72933-match-stack-overflow.rs",
+"ui/issues/issue-73112.rs",
+"ui/issues/issue-7344.rs",
+"ui/issues/issue-7364.rs",
+"ui/issues/issue-74082.rs",
+"ui/issues/issue-74564-if-expr-stack-overflow.rs",
+"ui/issues/issue-7519-match-unit-in-arg.rs",
+"ui/issues/issue-75283.rs",
+"ui/issues/issue-7563.rs",
+"ui/issues/issue-75704.rs",
+"ui/issues/issue-7575.rs",
+"ui/issues/issue-7607-1.rs",
+"ui/issues/issue-76077.rs",
+"ui/issues/issue-76191.rs",
+"ui/issues/issue-7660.rs",
+"ui/issues/issue-7663.rs",
+"ui/issues/issue-7784.rs",
+"ui/issues/issue-77919.rs",
+"ui/issues/issue-78192.rs",
+"ui/issues/issue-78622.rs",
+"ui/issues/issue-7867.rs",
+"ui/issues/issue-78957.rs",
+"ui/issues/issue-7899.rs",
+"ui/issues/issue-7911.rs",
+"ui/issues/issue-7950.rs",
+"ui/issues/issue-7970a.rs",
+"ui/issues/issue-8044.rs",
+"ui/issues/issue-80607.rs",
+"ui/issues/issue-8248.rs",
+"ui/issues/issue-8249.rs",
+"ui/issues/issue-8259.rs",
+"ui/issues/issue-8391.rs",
+"ui/issues/issue-8401.rs",
+"ui/issues/issue-8498.rs",
+"ui/issues/issue-8506.rs",
+"ui/issues/issue-86756.rs",
+"ui/issues/issue-87199.rs",
+"ui/issues/issue-8727.rs",
+"ui/issues/issue-87490.rs",
+"ui/issues/issue-8761.rs",
+"ui/issues/issue-8767.rs",
+"ui/issues/issue-8783.rs",
+"ui/issues/issue-8860.rs",
+"ui/issues/issue-8898.rs",
+"ui/issues/issue-9047.rs",
+"ui/issues/issue-9123.rs",
+"ui/issues/issue-9129.rs",
+"ui/issues/issue-9155.rs",
+"ui/issues/issue-9188.rs",
+"ui/issues/issue-9243.rs",
+"ui/issues/issue-9259.rs",
+"ui/issues/issue-9382.rs",
+"ui/issues/issue-9446.rs",
+"ui/issues/issue-9575.rs",
+"ui/issues/issue-9719.rs",
+"ui/issues/issue-9725.rs",
+"ui/issues/issue-9737.rs",
+"ui/issues/issue-9814.rs",
+"ui/issues/issue-98299.rs",
+"ui/issues/issue-9837.rs",
+"ui/issues/issue-9906.rs",
+"ui/issues/issue-9918.rs",
+"ui/issues/issue-9942.rs",
+"ui/issues/issue-9951.rs",
+"ui/issues/issue-9968.rs",
+"ui/issues/issue-99838.rs",
+"ui/issues/issue-11047.rs",
+"ui/issues/issue-11709.rs",
+"ui/issues/issue-20644.rs",
+"ui/issues/issue-23808.rs",
+"ui/issues/issue-26997.rs",
+"ui/issues/issue-28600.rs",
+"ui/issues/issue-3656.rs",
+"ui/issues/issue-50811.rs",
+"ui/issues/issue-51907.rs",
+"ui/issues/issue-5754.rs",
+"ui/issues/issue-10396.rs",
+"ui/issues/issue-10456.rs",
+"ui/issues/issue-106755.rs",
+"ui/issues/issue-10853.rs",
+"ui/issues/issue-10902.rs",
+"ui/issues/issue-11085.rs",
+"ui/issues/issue-11384.rs",
+"ui/issues/issue-11592.rs",
+"ui/issues/issue-11740.rs",
+"ui/issues/issue-11869.rs",
+"ui/issues/issue-12729.rs",
+"ui/issues/issue-12920.rs",
+"ui/issues/issue-13105.rs",
+"ui/issues/issue-13167.rs",
+"ui/issues/issue-13202.rs",
+"ui/issues/issue-13405.rs",
+"ui/issues/issue-13482-2.rs",
+"ui/issues/issue-13703.rs",
+"ui/issues/issue-13775.rs",
+"ui/issues/issue-14082.rs",
+"ui/issues/issue-14254.rs",
+"ui/issues/issue-14330.rs",
+"ui/issues/issue-14901.rs",
+"ui/issues/issue-14959.rs",
+"ui/issues/issue-15734.rs",
+"ui/issues/issue-15735.rs",
+"ui/issues/issue-16596.rs",
+"ui/issues/issue-16668.rs",
+"ui/issues/issue-16994.rs",
+"ui/issues/issue-17121.rs",
+"ui/issues/issue-17732.rs",
+"ui/issues/issue-17746.rs",
+"ui/issues/issue-17904.rs",
+"ui/issues/issue-18088.rs",
+"ui/issues/issue-18188.rs",
+"ui/issues/issue-18446-2.rs",
+"ui/issues/issue-18576.rs",
+"ui/issues/issue-18738.rs",
+"ui/issues/issue-18809.rs",
+"ui/issues/issue-18906.rs",
+"ui/issues/issue-18988.rs",
+"ui/issues/issue-19037.rs",
+"ui/issues/issue-19097.rs",
+"ui/issues/issue-19098.rs",
+"ui/issues/issue-19100.rs",
+"ui/issues/issue-19102.rs",
+"ui/issues/issue-19129-1.rs",
+"ui/issues/issue-19129-2.rs",
+"ui/issues/issue-19398.rs",
+"ui/issues/issue-19479.rs",
+"ui/issues/issue-19601.rs",
+"ui/issues/issue-1962.rs",
+"ui/issues/issue-19631.rs",
+"ui/issues/issue-19632.rs",
+"ui/issues/issue-19850.rs",
+"ui/issues/issue-19982.rs",
+"ui/issues/issue-20009.rs",
+"ui/issues/issue-20186.rs",
+"ui/issues/issue-20396.rs",
+"ui/issues/issue-20414.rs",
+"ui/issues/issue-20454.rs",
+"ui/issues/issue-20763-1.rs",
+"ui/issues/issue-20763-2.rs",
+"ui/issues/issue-20971.rs",
+"ui/issues/issue-21140.rs",
+"ui/issues/issue-21174-2.rs",
+"ui/issues/issue-21245.rs",
+"ui/issues/issue-21402.rs",
+"ui/issues/issue-21622.rs",
+"ui/issues/issue-22356.rs",
+"ui/issues/issue-22471.rs",
+"ui/issues/issue-22603.rs",
+"ui/issues/issue-22673.rs",
+"ui/issues/issue-22777.rs",
+"ui/issues/issue-22781.rs",
+"ui/issues/issue-22789.rs",
+"ui/issues/issue-22814.rs",
+"ui/issues/issue-22933-1.rs",
+"ui/issues/issue-2311-2.rs",
+"ui/issues/issue-2311.rs",
+"ui/issues/issue-2312.rs",
+"ui/issues/issue-23354-2.rs",
+"ui/issues/issue-23354.rs",
+"ui/issues/issue-23442.rs",
+"ui/issues/issue-23477.rs",
+"ui/issues/issue-24161.rs",
+"ui/issues/issue-24227.rs",
+"ui/issues/issue-24389.rs",
+"ui/issues/issue-24434.rs",
+"ui/issues/issue-2470-bounds-check-overflow.rs",
+"ui/issues/issue-24945-repeat-dash-opts.rs",
+"ui/issues/issue-2502.rs",
+"ui/issues/issue-25180.rs",
+"ui/issues/issue-25394.rs",
+"ui/issues/issue-25579.rs",
+"ui/issues/issue-26095.rs",
+"ui/issues/issue-2611-3.rs",
+"ui/issues/issue-26186.rs",
+"ui/issues/issue-26205.rs",
+"ui/issues/issue-26484.rs",
+"ui/issues/issue-26614.rs",
+"ui/issues/issue-26646.rs",
+"ui/issues/issue-27105.rs",
+"ui/issues/issue-27281.rs",
+"ui/issues/issue-27433.rs",
+"ui/issues/issue-2761.rs",
+"ui/issues/issue-27697.rs",
+"ui/issues/issue-27889.rs",
+"ui/issues/issue-28279.rs",
+"ui/issues/issue-28561.rs",
+"ui/issues/issue-28776.rs",
+"ui/issues/issue-28936.rs",
+"ui/issues/issue-28999.rs",
+"ui/issues/issue-29030.rs",
+"ui/issues/issue-29037.rs",
+"ui/issues/issue-29048.rs",
+"ui/issues/issue-29071.rs",
+"ui/issues/issue-29265.rs",
+"ui/issues/issue-29276.rs",
+"ui/issues/issue-29516.rs",
+"ui/issues/issue-29710.rs",
+"ui/issues/issue-29740.rs",
+"ui/issues/issue-29743.rs",
+"ui/issues/issue-29857.rs",
+"ui/issues/issue-3029.rs",
+"ui/issues/issue-30380.rs",
+"ui/issues/issue-31260.rs",
+"ui/issues/issue-3149.rs",
+"ui/issues/issue-32122-1.rs",
+"ui/issues/issue-32122-2.rs",
+"ui/issues/issue-32324.rs",
+"ui/issues/issue-32797.rs",
+"ui/issues/issue-33096.rs",
+"ui/issues/issue-33241.rs",
+"ui/issues/issue-33941.rs",
+"ui/issues/issue-3424.rs",
+"ui/issues/issue-34418.rs",
+"ui/issues/issue-34569.rs",
+"ui/issues/issue-34721.rs",
+"ui/issues/issue-34751.rs",
+"ui/issues/issue-34780.rs",
+"ui/issues/issue-34839.rs",
+"ui/issues/issue-3521-2.rs",
+"ui/issues/issue-35976.rs",
+"ui/issues/issue-36075.rs",
+"ui/issues/issue-3609.rs",
+"ui/issues/issue-36116.rs",
+"ui/issues/issue-36379.rs",
+"ui/issues/issue-3668-2.rs",
+"ui/issues/issue-36839.rs",
+"ui/issues/issue-36856.rs",
+"ui/issues/issue-37051.rs",
+"ui/issues/issue-37131.rs",
+"ui/issues/issue-37510.rs",
+"ui/issues/issue-37598.rs",
+"ui/issues/issue-37665.rs",
+"ui/issues/issue-38160.rs",
+"ui/issues/issue-38226.rs",
+"ui/issues/issue-38381.rs",
+"ui/issues/issue-3888-2.rs",
+"ui/issues/issue-39089.rs",
+"ui/issues/issue-39367.rs",
+"ui/issues/issue-39467.rs",
+"ui/issues/issue-3979-2.rs",
+"ui/issues/issue-3991.rs",
+"ui/issues/issue-39984.rs",
+"ui/issues/issue-40136.rs",
+"ui/issues/issue-4025.rs",
+"ui/issues/issue-40350.rs",
+"ui/issues/issue-40510-2.rs",
+"ui/issues/issue-40510-4.rs",
+"ui/issues/issue-40782.rs",
+"ui/issues/issue-41272.rs",
+"ui/issues/issue-41298.rs",
+"ui/issues/issue-41628.rs",
+"ui/issues/issue-41936-variance-coerce-unsized-cycle.rs",
+"ui/issues/issue-41998.rs",
+"ui/issues/issue-42210.rs",
+"ui/issues/issue-42467.rs",
+"ui/issues/issue-42956.rs",
+"ui/issues/issue-43057.rs",
+"ui/issues/issue-43357.rs",
+"ui/issues/issue-43483.rs",
+"ui/issues/issue-43806.rs",
+"ui/issues/issue-44056.rs",
+"ui/issues/issue-44216-add-instant.rs",
+"ui/issues/issue-44216-add-system-time.rs",
+"ui/issues/issue-44216-sub-instant.rs",
+"ui/issues/issue-44216-sub-system-time.rs",
+"ui/issues/issue-44239.rs",
+"ui/issues/issue-44247.rs",
+"ui/issues/issue-4464.rs",
+"ui/issues/issue-44730.rs",
+"ui/issues/issue-44851.rs",
+"ui/issues/issue-45425.rs",
+"ui/issues/issue-45562.rs",
+"ui/issues/issue-45697-1.rs",
+"ui/issues/issue-45697.rs",
+"ui/issues/issue-45731.rs",
+"ui/issues/issue-46756-consider-borrowing-cast-or-binexpr.rs",
+"ui/issues/issue-46855.rs",
+"ui/issues/issue-46964.rs",
+"ui/issues/issue-47309.rs",
+"ui/issues/issue-47364.rs",
+"ui/issues/issue-47673.rs",
+"ui/issues/issue-47703-1.rs",
+"ui/issues/issue-47703-tuple.rs",
+"ui/issues/issue-47703.rs",
+"ui/issues/issue-47722.rs",
+"ui/issues/issue-48131.rs",
+"ui/issues/issue-4830.rs",
+"ui/issues/issue-49544.rs",
+"ui/issues/issue-50187.rs",
+"ui/issues/issue-50411.rs",
+"ui/issues/issue-50471.rs",
+"ui/issues/issue-50518.rs",
+"ui/issues/issue-50571.rs",
+"ui/issues/issue-5067.rs",
+"ui/issues/issue-51655.rs",
+"ui/issues/issue-51798.rs",
+"ui/issues/issue-52489.rs",
+"ui/issues/issue-53333.rs",
+"ui/issues/issue-53419.rs",
+"ui/issues/issue-53568.rs",
+"ui/issues/issue-54094.rs",
+"ui/issues/issue-54462-mutable-noalias-correctness.rs",
+"ui/issues/issue-5572.rs",
+"ui/issues/issue-56128.rs",
+"ui/issues/issue-56175.rs",
+"ui/issues/issue-56229.rs",
+"ui/issues/issue-57156.rs",
+"ui/issues/issue-57162.rs",
+"ui/issues/issue-57399-self-return-impl-trait.rs",
+"ui/issues/issue-57741.rs",
+"ui/issues/issue-58212.rs",
+"ui/issues/issue-58344.rs",
+"ui/issues/issue-58375-monomorphize-default-impls.rs",
+"ui/issues/issue-5844.rs",
+"ui/issues/issue-58463.rs",
+"ui/issues/issue-5900.rs",
+"ui/issues/issue-59020.rs",
+"ui/issues/issue-59326.rs",
+"ui/issues/issue-5950.rs",
+"ui/issues/issue-59756.rs",
+"ui/issues/issue-64430.rs",
+"ui/issues/issue-64593.rs",
+"ui/issues/issue-6557.rs",
+"ui/issues/issue-65634-raw-ident-suggestion.rs",
+"ui/issues/issue-66308.rs",
+"ui/issues/issue-66768.rs",
+"ui/issues/issue-68951.rs",
+"ui/issues/issue-6898.rs",
+"ui/issues/issue-69225-SCEVAddExpr-wrap-flag.rs",
+"ui/issues/issue-69225-layout-repeated-checked-add.rs",
+"ui/issues/issue-70746.rs",
+"ui/issues/issue-71676-1.rs",
+"ui/issues/issue-72002.rs",
+"ui/issues/issue-7268.rs",
+"ui/issues/issue-73229.rs",
+"ui/issues/issue-76042.rs",
+"ui/issues/issue-7607-2.rs",
+"ui/issues/issue-76077-1.rs",
+"ui/issues/issue-7673-cast-generically-implemented-trait.rs",
+"ui/issues/issue-81584.rs",
+"ui/issues/issue-8171-default-method-self-inherit-builtin-trait.rs",
+"ui/issues/issue-81918.rs",
+"ui/issues/issue-82833-slice-miscompile.rs",
+"ui/issues/issue-83048.rs",
+"ui/issues/issue-8398.rs",
+"ui/issues/issue-8521.rs",
+"ui/issues/issue-8578.rs",
+"ui/issues/issue-87707.rs",
+"ui/issues/issue-88150.rs",
+"ui/issues/issue-9110.rs",
+"ui/issues/issue-91489.rs",
+"ui/issues/issue-9249.rs",
+"ui/issues/issue-92741.rs",
+"ui/issues/issue-12133-3.rs",
+"ui/issues/issue-18389.rs",
+"ui/issues/issue-35570.rs",
+"ui/issues/issue-51714.rs",
+"ui/issues/issue-5883.rs",
+"ui/issues/issue-67552.rs",
+"ui/issues/issue-85461.rs",
+"ui/iterators/issue-28098.rs",
+"ui/iterators/issue-58952-filter-type-length.rs",
+"ui/lang-items/issue-31076.rs",
+"ui/lang-items/issue-83471.rs",
+"ui/lang-items/issue-86238.rs",
+"ui/lang-items/issue-87573.rs",
+"ui/lang-items/issue-19660.rs",
+"ui/late-bound-lifetimes/issue-36381.rs",
+"ui/late-bound-lifetimes/issue-80618.rs",
+"ui/late-bound-lifetimes/issue-47511.rs",
+"ui/layout/issue-60431-unsized-tail-behind-projection.rs",
+"ui/layout/issue-84108.rs",
+"ui/layout/issue-113941.rs",
+"ui/layout/issue-96158-scalarpair-payload-might-be-uninit.rs",
+"ui/layout/issue-96185-overaligned-enum.rs",
+"ui/layout/issue-112048-unsizing-field-order.rs",
+"ui/layout/issue-112048-unsizing-niche.rs",
+"ui/let-else/issue-94176.rs",
+"ui/let-else/issue-100103.rs",
+"ui/let-else/issue-102317.rs",
+"ui/let-else/issue-99975.rs",
+"ui/lifetimes/auxiliary/issue-91763-aux.rs",
+"ui/lifetimes/lifetime-errors/issue_74400.rs",
+"ui/lifetimes/issue-105675.rs",
+"ui/lifetimes/issue-107492-default-value-for-lifetime.rs",
+"ui/lifetimes/issue-107988.rs",
+"ui/lifetimes/issue-17728.rs",
+"ui/lifetimes/issue-26638.rs",
+"ui/lifetimes/issue-34979.rs",
+"ui/lifetimes/issue-36744-without-calls.rs",
+"ui/lifetimes/issue-55796.rs",
+"ui/lifetimes/issue-64173-unused-lifetimes.rs",
+"ui/lifetimes/issue-79187-2.rs",
+"ui/lifetimes/issue-79187.rs",
+"ui/lifetimes/issue-83753-invalid-associated-type-supertrait-hrtb.rs",
+"ui/lifetimes/issue-83907-invalid-fn-like-path.rs",
+"ui/lifetimes/issue-90600-expected-return-static-indirect.rs",
+"ui/lifetimes/issue-91763.rs",
+"ui/lifetimes/issue-95023.rs",
+"ui/lifetimes/issue-97193.rs",
+"ui/lifetimes/issue-97194.rs",
+"ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.rs",
+"ui/lifetimes/issue-104432-unused-lifetimes-in-expansion.rs",
+"ui/lifetimes/issue-105227.rs",
+"ui/lifetimes/issue-105507.rs",
+"ui/lifetimes/issue-54378.rs",
+"ui/lifetimes/issue-67498.rs",
+"ui/lifetimes/issue-69314.rs",
+"ui/lifetimes/issue-70917-lifetimes-in-fn-def.rs",
+"ui/lifetimes/issue-76168-hr-outlives-2.rs",
+"ui/lifetimes/issue-76168-hr-outlives.rs",
+"ui/lifetimes/issue-77175.rs",
+"ui/lifetimes/issue-83737-binders-across-types.rs",
+"ui/lifetimes/issue-83737-erasing-bound-vars.rs",
+"ui/lifetimes/issue-84398.rs",
+"ui/lifetimes/issue-84604.rs",
+"ui/lifetimes/issue-90170-elision-mismatch.rs",
+"ui/lifetimes/issue-93911.rs",
+"ui/limits/issue-75158-64.rs",
+"ui/limits/issue-55878.rs",
+"ui/limits/issue-69485-var-size-diffs-too-large.rs",
+"ui/limits/issue-15919-32.rs",
+"ui/limits/issue-15919-64.rs",
+"ui/limits/issue-17913.rs",
+"ui/limits/issue-56762.rs",
+"ui/linkage-attr/issue-109144.rs",
+"ui/linkage-attr/issue-10755.rs",
+"ui/lint/dead-code/issue-59003.rs",
+"ui/lint/dead-code/issue-68408-false-positive.rs",
+"ui/lint/dead-code/issue-85071-2.rs",
+"ui/lint/dead-code/issue-85071.rs",
+"ui/lint/dead-code/issue-85255.rs",
+"ui/lint/must_not_suspend/issue-89562.rs",
+"ui/lint/unused/issue-105061-array-lint.rs",
+"ui/lint/unused/issue-105061-should-lint.rs",
+"ui/lint/unused/issue-105061.rs",
+"ui/lint/unused/issue-30730.rs",
+"ui/lint/unused/issue-46576.rs",
+"ui/lint/unused/issue-59896.rs",
+"ui/lint/unused/issue-67691-unused-field-in-or-pattern.rs",
+"ui/lint/unused/issue-74883-unused-paren-baren-yield.rs",
+"ui/lint/unused/issue-85913.rs",
+"ui/lint/unused/issue-90807-unused-paren-error.rs",
+"ui/lint/unused/issue-92751.rs",
+"ui/lint/unused/issue-96606.rs",
+"ui/lint/unused/issue-103320-must-use-ops.rs",
+"ui/lint/unused/issue-104397.rs",
+"ui/lint/unused/issue-47390-unused-variable-in-struct-pattern.rs",
+"ui/lint/unused/issue-54180-unused-ref-field.rs",
+"ui/lint/unused/issue-54538-unused-parens-lint.rs",
+"ui/lint/unused/issue-70041.rs",
+"ui/lint/unused/issue-71290-unused-paren-binop.rs",
+"ui/lint/unused/issue-81314-unused-span-ident.rs",
+"ui/lint/unused/issue-88519-unused-paren.rs",
+"ui/lint/unused/issue-90807-unused-paren.rs",
+"ui/lint/use-redundant/issue-92904.rs",
+"ui/lint/issue-104392.rs",
+"ui/lint/issue-106991.rs",
+"ui/lint/issue-109152.rs",
+"ui/lint/issue-111359.rs",
+"ui/lint/issue-14309.rs",
+"ui/lint/issue-17718-const-naming.rs",
+"ui/lint/issue-1866.rs",
+"ui/lint/issue-20343.rs",
+"ui/lint/issue-30302.rs",
+"ui/lint/issue-34798.rs",
+"ui/lint/issue-35075.rs",
+"ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs",
+"ui/lint/issue-63364.rs",
+"ui/lint/issue-66362-no-snake-case-warning-for-field-puns.rs",
+"ui/lint/issue-79744.rs",
+"ui/lint/issue-97094.rs",
+"ui/lint/issue-101284.rs",
+"ui/lint/issue-102705.rs",
+"ui/lint/issue-103317.rs",
+"ui/lint/issue-103435-extra-parentheses.rs",
+"ui/lint/issue-104897.rs",
+"ui/lint/issue-108155.rs",
+"ui/lint/issue-109529.rs",
+"ui/lint/issue-110573.rs",
+"ui/lint/issue-112489.rs",
+"ui/lint/issue-14837.rs",
+"ui/lint/issue-31924-non-snake-ffi.rs",
+"ui/lint/issue-47775-nested-macro-unnecessary-parens-arg.rs",
+"ui/lint/issue-54099-camel-case-underscore-types.rs",
+"ui/lint/issue-57410-1.rs",
+"ui/lint/issue-57410.rs",
+"ui/lint/issue-70819-dont-override-forbid-in-same-scope.rs",
+"ui/lint/issue-79546-fuel-ice.rs",
+"ui/lint/issue-80988.rs",
+"ui/lint/issue-81218.rs",
+"ui/lint/issue-83477.rs",
+"ui/lint/issue-86600-lint-twice.rs",
+"ui/lint/issue-87274-paren-parent.rs",
+"ui/lint/issue-89469.rs",
+"ui/lint/issue-90614-accept-allow-text-direction-codepoint-in-comment-lint.rs",
+"ui/lint/issue-99387.rs",
+"ui/loops/issue-50576.rs",
+"ui/loops/issue-82916.rs",
+"ui/lowering/issue-96847.rs",
+"ui/lto/issue-105637.rs",
+"ui/lto/issue-100772.rs",
+"ui/lto/issue-11154.rs",
+"ui/macros/auxiliary/issue-100199.rs",
+"ui/macros/auxiliary/issue-19163.rs",
+"ui/macros/auxiliary/issue-40469.rs",
+"ui/macros/auxiliary/issue-75982.rs",
+"ui/macros/issue-100199.rs",
+"ui/macros/issue-102878.rs",
+"ui/macros/issue-103529.rs",
+"ui/macros/issue-104769-concat_bytes-invalid-literal.rs",
+"ui/macros/issue-105011.rs",
+"ui/macros/issue-10536.rs",
+"ui/macros/issue-106837.rs",
+"ui/macros/issue-109237.rs",
+"ui/macros/issue-111749.rs",
+"ui/macros/issue-16098.rs",
+"ui/macros/issue-19163.rs",
+"ui/macros/issue-21356.rs",
+"ui/macros/issue-22463.rs",
+"ui/macros/issue-25274.rs",
+"ui/macros/issue-25385.rs",
+"ui/macros/issue-26094.rs",
+"ui/macros/issue-26322.rs",
+"ui/macros/issue-29084.rs",
+"ui/macros/issue-30143.rs",
+"ui/macros/issue-33185.rs",
+"ui/macros/issue-34421-mac-expr-bad-stmt-good-add-semi.rs",
+"ui/macros/issue-35450.rs",
+"ui/macros/issue-37175.rs",
+"ui/macros/issue-38715.rs",
+"ui/macros/issue-39388.rs",
+"ui/macros/issue-39404.rs",
+"ui/macros/issue-40469.rs",
+"ui/macros/issue-40770.rs",
+"ui/macros/issue-41776.rs",
+"ui/macros/issue-41803.rs",
+"ui/macros/issue-44127.rs",
+"ui/macros/issue-5060.rs",
+"ui/macros/issue-51848.rs",
+"ui/macros/issue-52169.rs",
+"ui/macros/issue-54441.rs",
+"ui/macros/issue-58490.rs",
+"ui/macros/issue-61033-1.rs",
+"ui/macros/issue-61033-2.rs",
+"ui/macros/issue-61053-different-kleene.rs",
+"ui/macros/issue-61053-duplicate-binder.rs",
+"ui/macros/issue-61053-missing-repetition.rs",
+"ui/macros/issue-61053-unbound.rs",
+"ui/macros/issue-6596-1.rs",
+"ui/macros/issue-68060.rs",
+"ui/macros/issue-69396-const-no-type-in-macro.rs",
+"ui/macros/issue-78325-inconsistent-resolution.rs",
+"ui/macros/issue-78333.rs",
+"ui/macros/issue-81006.rs",
+"ui/macros/issue-83340.rs",
+"ui/macros/issue-83344.rs",
+"ui/macros/issue-84195-lint-anon-const.rs",
+"ui/macros/issue-84632-eager-expansion-recursion-limit.rs",
+"ui/macros/issue-86865.rs",
+"ui/macros/issue-8709.rs",
+"ui/macros/issue-8851.rs",
+"ui/macros/issue-92267.rs",
+"ui/macros/issue-98790.rs",
+"ui/macros/issue-112342-1.rs",
+"ui/macros/issue-112342-2.rs",
+"ui/macros/issue-2804-2.rs",
+"ui/macros/issue-34171.rs",
+"ui/macros/issue-42954.rs",
+"ui/macros/issue-57597.rs",
+"ui/macros/issue-63102.rs",
+"ui/macros/issue-68058.rs",
+"ui/macros/issue-69838-mods-relative-to-included-path.rs",
+"ui/macros/issue-70446.rs",
+"ui/macros/issue-75982-foreign-macro-weird-mod.rs",
+"ui/macros/issue-77475.rs",
+"ui/macros/issue-78892-substitution-in-statement-attr.rs",
+"ui/macros/issue-84429-matches-edition.rs",
+"ui/macros/issue-86082-option-env-invalid-char.rs",
+"ui/macros/issue-87877.rs",
+"ui/macros/issue-88206.rs",
+"ui/macros/issue-88228.rs",
+"ui/macros/issue-95267.rs",
+"ui/macros/issue-95533.rs",
+"ui/macros/issue-98466-allow.rs",
+"ui/macros/issue-98466.rs",
+"ui/macros/issue-99261.rs",
+"ui/macros/issue-99265.rs",
+"ui/macros/issue-99907.rs",
+"ui/malformed/issue-69341-malformed-derive-inert.rs",
+"ui/malformed/issue-107423-unused-delim-only-one-no-pair.rs",
+"ui/marker_trait_attr/issue-61651-type-mismatch.rs",
+"ui/match/issue-11319.rs",
+"ui/match/issue-11940.rs",
+"ui/match/issue-12552.rs",
+"ui/match/issue-18060.rs",
+"ui/match/issue-26251.rs",
+"ui/match/issue-26996.rs",
+"ui/match/issue-27021.rs",
+"ui/match/issue-33498.rs",
+"ui/match/issue-41255.rs",
+"ui/match/issue-42679.rs",
+"ui/match/issue-46920-byte-array-patterns.rs",
+"ui/match/issue-5530.rs",
+"ui/match/issue-56685.rs",
+"ui/match/issue-72680.rs",
+"ui/match/issue-72896.rs",
+"ui/match/issue-74050-end-span.rs",
+"ui/match/issue-82866.rs",
+"ui/match/issue-91058.rs",
+"ui/match/issue-92100.rs",
+"ui/match/issue-112438.rs",
+"ui/match/issue-70972-dyn-trait.rs",
+"ui/match/issue-82392.rs",
+"ui/match/issue-84434.rs",
+"ui/match/issue-113012.rs",
+"ui/methods/issues/issue-105732.rs",
+"ui/methods/issues/issue-61525.rs",
+"ui/methods/issues/issue-84495.rs",
+"ui/methods/issues/issue-90315.rs",
+"ui/methods/issues/issue-94581.rs",
+"ui/mir/auxiliary/issue_76375_aux.rs",
+"ui/mir/validate/issue-95978-validator-lifetime-comparison.rs",
+"ui/mir/issue-102389.rs",
+"ui/mir/issue-107678-projection-with-lifetime.rs",
+"ui/mir/issue-29227.rs",
+"ui/mir/issue-67947.rs",
+"ui/mir/issue-75419-validation-impl-trait.rs",
+"ui/mir/issue-76803-branches-not-same.rs",
+"ui/mir/issue-77359-simplify-arm-identity.rs",
+"ui/mir/issue-83499-input-output-iteration-ice.rs",
+"ui/mir/issue-89485.rs",
+"ui/mir/issue-92893.rs",
+"ui/mir/issue-112269.rs",
+"ui/mir/issue-80949.rs",
+"ui/mir/issue-101844.rs",
+"ui/mir/issue-105809.rs",
+"ui/mir/issue-106062.rs",
+"ui/mir/issue-107691.rs",
+"ui/mir/issue-109004-drop-large-array.rs",
+"ui/mir/issue-109743.rs",
+"ui/mir/issue-46845.rs",
+"ui/mir/issue-60390.rs",
+"ui/mir/issue-66851.rs",
+"ui/mir/issue-66930.rs",
+"ui/mir/issue-67639-normalization-ice.rs",
+"ui/mir/issue-67710-inline-projection.rs",
+"ui/mir/issue-68841.rs",
+"ui/mir/issue-71793-inline-args-storage.rs",
+"ui/mir/issue-73914.rs",
+"ui/mir/issue-74739.rs",
+"ui/mir/issue-75053.rs",
+"ui/mir/issue-76248.rs",
+"ui/mir/issue-76375.rs",
+"ui/mir/issue-76740-copy-propagation.rs",
+"ui/mir/issue-77002.rs",
+"ui/mir/issue-77911.rs",
+"ui/mir/issue-78496.rs",
+"ui/mir/issue-91745.rs",
+"ui/mir/issue-99852.rs",
+"ui/mir/issue-99866.rs",
+"ui/mir/issue66339.rs",
+"ui/mismatched_types/issue-19109.rs",
+"ui/mismatched_types/issue-26480.rs",
+"ui/mismatched_types/issue-35030.rs",
+"ui/mismatched_types/issue-36053-2.rs",
+"ui/mismatched_types/issue-38371-unfixable.rs",
+"ui/mismatched_types/issue-47706-trait.rs",
+"ui/mismatched_types/issue-47706.rs",
+"ui/mismatched_types/issue-74918-missing-lifetime.rs",
+"ui/mismatched_types/issue-75361-mismatched-impl.rs",
+"ui/mismatched_types/issue-84976.rs",
+"ui/mismatched_types/issue-112036.rs",
+"ui/mismatched_types/issue-106182.rs",
+"ui/mismatched_types/issue-38371.rs",
+"ui/missing-trait-bounds/auxiliary/issue-69725.rs",
+"ui/missing-trait-bounds/issue-35677.rs",
+"ui/missing-trait-bounds/issue-69725.rs",
+"ui/modules/issue-56411.rs",
+"ui/modules/issue-107649.rs",
+"ui/modules/issue-56411-aux.rs",
+"ui/moves/issue-22536-copy-mustnt-zero.rs",
+"ui/moves/issue-46099-move-in-macro.rs",
+"ui/moves/issue-72649-uninit-in-loop.rs",
+"ui/moves/issue-75904-move-closure-loop.rs",
+"ui/moves/issue-99470-move-out-of-some.rs",
+"ui/never_type/issue-10176.rs",
+"ui/never_type/issue-13352.rs",
+"ui/never_type/issue-2149.rs",
+"ui/never_type/issue-51506.rs",
+"ui/never_type/issue-52443.rs",
+"ui/never_type/issue-96335.rs",
+"ui/never_type/issue-44402.rs",
+"ui/never_type/issue-5500-1.rs",
+"ui/nll/closure-requirements/issue-58127-mutliple-requirements.rs",
+"ui/nll/polonius/issue-46589.rs",
+"ui/nll/relate_tys/issue-48071.rs",
+"ui/nll/ty-outlives/issue-53789-1.rs",
+"ui/nll/ty-outlives/issue-53789-2.rs",
+"ui/nll/ty-outlives/issue-55756.rs",
+"ui/nll/user-annotations/issue-54124.rs",
+"ui/nll/user-annotations/issue-55241.rs",
+"ui/nll/user-annotations/issue-55748-pat-types-constrain-bindings.rs",
+"ui/nll/user-annotations/issue-57731-ascibed-coupled-types.rs",
+"ui/nll/user-annotations/issue-54570-bootstrapping.rs",
+"ui/nll/user-annotations/issue-55219.rs",
+"ui/nll/issue-21232-partial-init-and-erroneous-use.rs",
+"ui/nll/issue-21232-partial-init-and-use.rs",
+"ui/nll/issue-24535-allow-mutable-borrow-in-match-guard.rs",
+"ui/nll/issue-27282-move-match-input-into-guard.rs",
+"ui/nll/issue-27282-move-ref-mut-into-guard.rs",
+"ui/nll/issue-27282-mutate-before-diverging-arm-1.rs",
+"ui/nll/issue-27282-mutate-before-diverging-arm-2.rs",
+"ui/nll/issue-27282-mutate-before-diverging-arm-3.rs",
+"ui/nll/issue-27282-mutation-in-guard.rs",
+"ui/nll/issue-27282-reborrow-ref-mut-in-guard.rs",
+"ui/nll/issue-27868.rs",
+"ui/nll/issue-30438-a.rs",
+"ui/nll/issue-30438-b.rs",
+"ui/nll/issue-30438-c.rs",
+"ui/nll/issue-31567.rs",
+"ui/nll/issue-42574-diagnostic-in-nested-closure.rs",
+"ui/nll/issue-45157.rs",
+"ui/nll/issue-45696-long-live-borrows-in-boxes.rs",
+"ui/nll/issue-45696-no-variant-box-recur.rs",
+"ui/nll/issue-45696-scribble-on-boxed-borrow.rs",
+"ui/nll/issue-46023.rs",
+"ui/nll/issue-46036.rs",
+"ui/nll/issue-46589.rs",
+"ui/nll/issue-47153-generic-const.rs",
+"ui/nll/issue-47388.rs",
+"ui/nll/issue-47470.rs",
+"ui/nll/issue-47589.rs",
+"ui/nll/issue-48070.rs",
+"ui/nll/issue-48238.rs",
+"ui/nll/issue-48623-closure.rs",
+"ui/nll/issue-48623-generator.rs",
+"ui/nll/issue-48697.rs",
+"ui/nll/issue-48803.rs",
+"ui/nll/issue-50343.rs",
+"ui/nll/issue-50461-used-mut-from-moves.rs",
+"ui/nll/issue-50716.rs",
+"ui/nll/issue-51191.rs",
+"ui/nll/issue-51244.rs",
+"ui/nll/issue-51268.rs",
+"ui/nll/issue-51512.rs",
+"ui/nll/issue-52057.rs",
+"ui/nll/issue-52059-report-when-borrow-and-drop-conflict.rs",
+"ui/nll/issue-52086.rs",
+"ui/nll/issue-52113.rs",
+"ui/nll/issue-52213.rs",
+"ui/nll/issue-52533-1.rs",
+"ui/nll/issue-52534-1.rs",
+"ui/nll/issue-52534-2.rs",
+"ui/nll/issue-52534.rs",
+"ui/nll/issue-52663-span-decl-captured-variable.rs",
+"ui/nll/issue-52663-trait-object.rs",
+"ui/nll/issue-52669.rs",
+"ui/nll/issue-52742.rs",
+"ui/nll/issue-53040.rs",
+"ui/nll/issue-53123-raw-pointer-cast.rs",
+"ui/nll/issue-53773.rs",
+"ui/nll/issue-53807.rs",
+"ui/nll/issue-54189.rs",
+"ui/nll/issue-54302-cases.rs",
+"ui/nll/issue-54302.rs",
+"ui/nll/issue-54382-use-span-of-tail-of-block.rs",
+"ui/nll/issue-54556-niconii.rs",
+"ui/nll/issue-54556-stephaneyfx.rs",
+"ui/nll/issue-54556-temps-in-tail-diagnostic.rs",
+"ui/nll/issue-54556-used-vs-unused-tails.rs",
+"ui/nll/issue-54556-wrap-it-up.rs",
+"ui/nll/issue-54779-anon-static-lifetime.rs",
+"ui/nll/issue-54943.rs",
+"ui/nll/issue-55394.rs",
+"ui/nll/issue-55401.rs",
+"ui/nll/issue-55511.rs",
+"ui/nll/issue-55850.rs",
+"ui/nll/issue-57100.rs",
+"ui/nll/issue-57265-return-type-wf-check.rs",
+"ui/nll/issue-57280-1-flipped.rs",
+"ui/nll/issue-57642-higher-ranked-subtype.rs",
+"ui/nll/issue-57843.rs",
+"ui/nll/issue-57960.rs",
+"ui/nll/issue-57989.rs",
+"ui/nll/issue-58053.rs",
+"ui/nll/issue-58299.rs",
+"ui/nll/issue-62007-assign-const-index.rs",
+"ui/nll/issue-62007-assign-differing-fields.rs",
+"ui/nll/issue-67007-escaping-data.rs",
+"ui/nll/issue-68550.rs",
+"ui/nll/issue-69114-static-mut-ty.rs",
+"ui/nll/issue-69114-static-ty.rs",
+"ui/nll/issue-73159-rpit-static.rs",
+"ui/nll/issue-75777.rs",
+"ui/nll/issue-95272.rs",
+"ui/nll/issue-97997.rs",
+"ui/nll/issue-98170.rs",
+"ui/nll/issue-98589-closures-relate-named-regions.rs",
+"ui/nll/issue-98693.rs",
+"ui/nll/issue-112604-closure-output-normalize.rs",
+"ui/nll/issue-16223.rs",
+"ui/nll/issue-21114-ebfull.rs",
+"ui/nll/issue-21114-kixunil.rs",
+"ui/nll/issue-22323-temp-destruction.rs",
+"ui/nll/issue-27583.rs",
+"ui/nll/issue-30104.rs",
+"ui/nll/issue-32382-index-assoc-type-with-lifetime.rs",
+"ui/nll/issue-43058.rs",
+"ui/nll/issue-47022.rs",
+"ui/nll/issue-48179.rs",
+"ui/nll/issue-50716-1.rs",
+"ui/nll/issue-51345-2.rs",
+"ui/nll/issue-51351.rs",
+"ui/nll/issue-51770.rs",
+"ui/nll/issue-52078.rs",
+"ui/nll/issue-52992.rs",
+"ui/nll/issue-53119.rs",
+"ui/nll/issue-53570.rs",
+"ui/nll/issue-54943-3.rs",
+"ui/nll/issue-55288.rs",
+"ui/nll/issue-55344.rs",
+"ui/nll/issue-55651.rs",
+"ui/nll/issue-55825-const-fn.rs",
+"ui/nll/issue-57280-1.rs",
+"ui/nll/issue-57280.rs",
+"ui/nll/issue-61311-normalize.rs",
+"ui/nll/issue-61320-normalize.rs",
+"ui/nll/issue-61424.rs",
+"ui/nll/issue-63154-normalize.rs",
+"ui/nll/issue-78561.rs",
+"ui/numbers-arithmetic/issue-8460.rs",
+"ui/numbers-arithmetic/issue-105626.rs",
+"ui/numbers-arithmetic/issue-8460-const.rs",
+"ui/object-safety/issue-19538.rs",
+"ui/object-safety/issue-102762.rs",
+"ui/object-safety/issue-102933.rs",
+"ui/object-safety/issue-106247.rs",
+"ui/on-unimplemented/issue-104140.rs",
+"ui/or-patterns/issue-64879-trailing-before-guard.rs",
+"ui/or-patterns/issue-69875-should-have-been-expanded-earlier-non-exhaustive.rs",
+"ui/or-patterns/issue-67514-irrefutable-param.rs",
+"ui/or-patterns/issue-68785-irrefutable-param-with-at.rs",
+"ui/or-patterns/issue-69875-should-have-been-expanded-earlier.rs",
+"ui/or-patterns/issue-70413-no-unreachable-pat-and-guard.rs",
+"ui/overloaded/issue-14958.rs",
+"ui/packed/issue-27060-2.rs",
+"ui/packed/issue-27060.rs",
+"ui/packed/issue-46152.rs",
+"ui/panics/issue-47429-short-backtraces.rs",
+"ui/parser/issues/auxiliary/issue-21146-inc.rs",
+"ui/parser/issues/auxiliary/issue-89971-outer-attr-following-inner-attr-ice.rs",
+"ui/parser/issues/auxiliary/issue-94340-inc.rs",
+"ui/parser/issues/issue-101540.rs",
+"ui/parser/issues/issue-102182-impl-trait-recover.rs",
+"ui/parser/issues/issue-10392.rs",
+"ui/parser/issues/issue-104088.rs",
+"ui/parser/issues/issue-104367.rs",
+"ui/parser/issues/issue-10636-1.rs",
+"ui/parser/issues/issue-108242-semicolon-recovery.rs",
+"ui/parser/issues/issue-110014.rs",
+"ui/parser/issues/issue-111416.rs",
+"ui/parser/issues/issue-13483.rs",
+"ui/parser/issues/issue-14303.rs",
+"ui/parser/issues/issue-15914.rs",
+"ui/parser/issues/issue-15980.rs",
+"ui/parser/issues/issue-1655.rs",
+"ui/parser/issues/issue-17718-const-mut.rs",
+"ui/parser/issues/issue-17904-2.rs",
+"ui/parser/issues/issue-1802-1.rs",
+"ui/parser/issues/issue-1802-2.rs",
+"ui/parser/issues/issue-19096.rs",
+"ui/parser/issues/issue-19398.rs",
+"ui/parser/issues/issue-20616-1.rs",
+"ui/parser/issues/issue-20616-2.rs",
+"ui/parser/issues/issue-20616-3.rs",
+"ui/parser/issues/issue-20616-4.rs",
+"ui/parser/issues/issue-20616-5.rs",
+"ui/parser/issues/issue-20616-6.rs",
+"ui/parser/issues/issue-20616-7.rs",
+"ui/parser/issues/issue-20616-8.rs",
+"ui/parser/issues/issue-20616-9.rs",
+"ui/parser/issues/issue-20711-2.rs",
+"ui/parser/issues/issue-20711.rs",
+"ui/parser/issues/issue-21153.rs",
+"ui/parser/issues/issue-21475.rs",
+"ui/parser/issues/issue-22647.rs",
+"ui/parser/issues/issue-22712.rs",
+"ui/parser/issues/issue-2354-1.rs",
+"ui/parser/issues/issue-2354.rs",
+"ui/parser/issues/issue-23620-invalid-escapes.rs",
+"ui/parser/issues/issue-24197.rs",
+"ui/parser/issues/issue-24375.rs",
+"ui/parser/issues/issue-24780.rs",
+"ui/parser/issues/issue-27255.rs",
+"ui/parser/issues/issue-31804.rs",
+"ui/parser/issues/issue-32214.rs",
+"ui/parser/issues/issue-32446.rs",
+"ui/parser/issues/issue-32501.rs",
+"ui/parser/issues/issue-32505.rs",
+"ui/parser/issues/issue-33262.rs",
+"ui/parser/issues/issue-33413.rs",
+"ui/parser/issues/issue-33418.rs",
+"ui/parser/issues/issue-33455.rs",
+"ui/parser/issues/issue-34222-1.rs",
+"ui/parser/issues/issue-34255-1.rs",
+"ui/parser/issues/issue-41155.rs",
+"ui/parser/issues/issue-43196.rs",
+"ui/parser/issues/issue-43692.rs",
+"ui/parser/issues/issue-44021.rs",
+"ui/parser/issues/issue-44406.rs",
+"ui/parser/issues/issue-45296.rs",
+"ui/parser/issues/issue-48137-macros-cannot-interpolate-impl-items-bad-variants.rs",
+"ui/parser/issues/issue-48508-aux.rs",
+"ui/parser/issues/issue-49040.rs",
+"ui/parser/issues/issue-51602.rs",
+"ui/parser/issues/issue-52496.rs",
+"ui/parser/issues/issue-5544-a.rs",
+"ui/parser/issues/issue-5544-b.rs",
+"ui/parser/issues/issue-56031.rs",
+"ui/parser/issues/issue-57198.rs",
+"ui/parser/issues/issue-5806.rs",
+"ui/parser/issues/issue-58856-1.rs",
+"ui/parser/issues/issue-58856-2.rs",
+"ui/parser/issues/issue-59418.rs",
+"ui/parser/issues/issue-60075.rs",
+"ui/parser/issues/issue-62546.rs",
+"ui/parser/issues/issue-62660.rs",
+"ui/parser/issues/issue-62881.rs",
+"ui/parser/issues/issue-62895.rs",
+"ui/parser/issues/issue-62913.rs",
+"ui/parser/issues/issue-64732.rs",
+"ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs",
+"ui/parser/issues/issue-65257-invalid-var-decl-recovery.rs",
+"ui/parser/issues/issue-65846-rollback-gating-failing-matcher.rs",
+"ui/parser/issues/issue-6610.rs",
+"ui/parser/issues/issue-66357-unexpected-unreachable.rs",
+"ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.rs",
+"ui/parser/issues/issue-68000-unicode-ident-after-missing-comma.rs",
+"ui/parser/issues/issue-68890-2.rs",
+"ui/parser/issues/issue-68890.rs",
+"ui/parser/issues/issue-69259.rs",
+"ui/parser/issues/issue-70388-recover-dotdotdot-rest-pat.rs",
+"ui/parser/issues/issue-70549-resolve-after-recovered-self-ctor.rs",
+"ui/parser/issues/issue-70552-ascription-in-parens-after-call.rs",
+"ui/parser/issues/issue-70583-block-is-empty-1.rs",
+"ui/parser/issues/issue-70583-block-is-empty-2.rs",
+"ui/parser/issues/issue-7222.rs",
+"ui/parser/issues/issue-72253.rs",
+"ui/parser/issues/issue-72373.rs",
+"ui/parser/issues/issue-73568-lifetime-after-mut.rs",
+"ui/parser/issues/issue-7970b.rs",
+"ui/parser/issues/issue-81806.rs",
+"ui/parser/issues/issue-83639.rs",
+"ui/parser/issues/issue-84117.rs",
+"ui/parser/issues/issue-84148-1.rs",
+"ui/parser/issues/issue-8537.rs",
+"ui/parser/issues/issue-86895.rs",
+"ui/parser/issues/issue-87086-colon-path-sep.rs",
+"ui/parser/issues/issue-87635.rs",
+"ui/parser/issues/issue-87812-path.rs",
+"ui/parser/issues/issue-87812.rs",
+"ui/parser/issues/issue-88818.rs",
+"ui/parser/issues/issue-89388.rs",
+"ui/parser/issues/issue-89574.rs",
+"ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.rs",
+"ui/parser/issues/issue-90993.rs",
+"ui/parser/issues/issue-91461.rs",
+"ui/parser/issues/issue-93282.rs",
+"ui/parser/issues/issue-93867.rs",
+"ui/parser/issues/issue-94340.rs",
+"ui/parser/issues/issue-111148.rs",
+"ui/parser/issues/issue-111692.rs",
+"ui/parser/issues/issue-10392-2.rs",
+"ui/parser/issues/issue-105209.rs",
+"ui/parser/issues/issue-10636-2.rs",
+"ui/parser/issues/issue-14303-fncall.rs",
+"ui/parser/issues/issue-17904.rs",
+"ui/parser/issues/issue-21146.rs",
+"ui/parser/issues/issue-30318.rs",
+"ui/parser/issues/issue-3036.rs",
+"ui/parser/issues/issue-35813-postfix-after-cast.rs",
+"ui/parser/issues/issue-46186.rs",
+"ui/parser/issues/issue-48137-macros-cannot-interpolate-impl-items.rs",
+"ui/parser/issues/issue-48508.rs",
+"ui/parser/issues/issue-48636.rs",
+"ui/parser/issues/issue-54521-1.rs",
+"ui/parser/issues/issue-54521-2.rs",
+"ui/parser/issues/issue-54521-3.rs",
+"ui/parser/issues/issue-57684.rs",
+"ui/parser/issues/issue-57819.rs",
+"ui/parser/issues/issue-58094-missing-right-square-bracket.rs",
+"ui/parser/issues/issue-62524.rs",
+"ui/parser/issues/issue-62554.rs",
+"ui/parser/issues/issue-62894.rs",
+"ui/parser/issues/issue-62973.rs",
+"ui/parser/issues/issue-63115-range-pat-interpolated.rs",
+"ui/parser/issues/issue-63116.rs",
+"ui/parser/issues/issue-63135.rs",
+"ui/parser/issues/issue-65041-empty-vis-matcher-in-enum.rs",
+"ui/parser/issues/issue-65041-empty-vis-matcher-in-trait.rs",
+"ui/parser/issues/issue-66473.rs",
+"ui/parser/issues/issue-67146-negative-outlives-bound-syntactic-fail.rs",
+"ui/parser/issues/issue-68629.rs",
+"ui/parser/issues/issue-68730.rs",
+"ui/parser/issues/issue-68788-in-trait-item-propagation.rs",
+"ui/parser/issues/issue-70050-ntliteral-accepts-negated-lit.rs",
+"ui/parser/issues/issue-70388-without-witness.rs",
+"ui/parser/issues/issue-75599.rs",
+"ui/parser/issues/issue-76437-async.rs",
+"ui/parser/issues/issue-76437-const-async-unsafe.rs",
+"ui/parser/issues/issue-76437-const-async.rs",
+"ui/parser/issues/issue-76437-const.rs",
+"ui/parser/issues/issue-76437-pub-crate-unsafe.rs",
+"ui/parser/issues/issue-76437-unsafe.rs",
+"ui/parser/issues/issue-76597.rs",
+"ui/parser/issues/issue-84104.rs",
+"ui/parser/issues/issue-84148-2.rs",
+"ui/parser/issues/issue-87197-missing-semicolon.rs",
+"ui/parser/issues/issue-88276-unary-plus.rs",
+"ui/parser/issues/issue-88583-union-as-ident.rs",
+"ui/parser/issues/issue-88770.rs",
+"ui/parser/issues/issue-89396.rs",
+"ui/parser/issues/issue-112458.rs",
+"ui/parser/macro/issue-33569.rs",
+"ui/parser/macro/issue-37113.rs",
+"ui/parser/macro/issue-37234.rs",
+"ui/parser/raw/issue-70677-panic-on-unterminated-raw-str-at-eof.rs",
+"ui/parser/shebang/issue-71471-ignore-tidy.rs",
+"ui/parser/issue-102806.rs",
+"ui/parser/issue-103143.rs",
+"ui/parser/issue-103425.rs",
+"ui/parser/issue-103748-ICE-wrong-braces.rs",
+"ui/parser/issue-104620.rs",
+"ui/parser/issue-104867-inc-dec-2.rs",
+"ui/parser/issue-104867-inc-dec.rs",
+"ui/parser/issue-108495-dec.rs",
+"ui/parser/issue-17718-parse-const.rs",
+"ui/parser/issue-39616.rs",
+"ui/parser/issue-49257.rs",
+"ui/parser/issue-61858.rs",
+"ui/parser/issue-68091-unicode-ident-after-if.rs",
+"ui/parser/issue-68092-unicode-ident-after-incomplete-expr.rs",
+"ui/parser/issue-68987-unmatch-issue-1.rs",
+"ui/parser/issue-68987-unmatch-issue-2.rs",
+"ui/parser/issue-68987-unmatch-issue-3.rs",
+"ui/parser/issue-68987-unmatch-issue.rs",
+"ui/parser/issue-87694-duplicated-pub.rs",
+"ui/parser/issue-87694-misplaced-pub.rs",
+"ui/parser/issue-90728.rs",
+"ui/parser/issue-91421.rs",
+"ui/parser/issue-100197-mut-let.rs",
+"ui/parser/issue-101477-enum.rs",
+"ui/parser/issue-101477-let.rs",
+"ui/parser/issue-103381.rs",
+"ui/parser/issue-103451.rs",
+"ui/parser/issue-105366.rs",
+"ui/parser/issue-105634.rs",
+"ui/parser/issue-107705.rs",
+"ui/parser/issue-112188.rs",
+"ui/parser/issue-81804.rs",
+"ui/parser/issue-81827.rs",
+"ui/parser/issue-99625-enum-struct-mutually-exclusive.rs",
+"ui/parser/issue-99910-const-let-mutually-exclusive.rs",
+"ui/parser/issue-113342.rs",
+"ui/pattern/move-ref-patterns/issue-53840.rs",
+"ui/pattern/usefulness/issue-12116.rs",
+"ui/pattern/usefulness/issue-12369.rs",
+"ui/pattern/usefulness/issue-13727.rs",
+"ui/pattern/usefulness/issue-15129.rs",
+"ui/pattern/usefulness/issue-2111.rs",
+"ui/pattern/usefulness/issue-30240-b.rs",
+"ui/pattern/usefulness/issue-30240-rpass.rs",
+"ui/pattern/usefulness/issue-30240.rs",
+"ui/pattern/usefulness/issue-3096-1.rs",
+"ui/pattern/usefulness/issue-3096-2.rs",
+"ui/pattern/usefulness/issue-31221.rs",
+"ui/pattern/usefulness/issue-31561.rs",
+"ui/pattern/usefulness/issue-35609.rs",
+"ui/pattern/usefulness/issue-39362.rs",
+"ui/pattern/usefulness/issue-40221.rs",
+"ui/pattern/usefulness/issue-4321.rs",
+"ui/pattern/usefulness/issue-50900.rs",
+"ui/pattern/usefulness/issue-56379.rs",
+"ui/pattern/usefulness/issue-57472.rs",
+"ui/pattern/usefulness/issue-72377.rs",
+"ui/pattern/usefulness/issue-78123-non-exhaustive-reference.rs",
+"ui/pattern/usefulness/issue-82772-match-box-as-struct.rs",
+"ui/pattern/usefulness/issue-53820-slice-pattern-large-array.rs",
+"ui/pattern/usefulness/issue-65413-constants-and-slices-exhaustiveness.rs",
+"ui/pattern/usefulness/issue-66501.rs",
+"ui/pattern/usefulness/issue-71930-type-of-match-scrutinee.rs",
+"ui/pattern/usefulness/issue-72476-and-89393-associated-type.rs",
+"ui/pattern/usefulness/issue-78549-ref-pat-and-str.rs",
+"ui/pattern/usefulness/issue-80501-or-pat-and-macro.rs",
+"ui/pattern/usefulness/issue-88747.rs",
+"ui/pattern/usefulness/issue-3601.rs",
+"ui/pattern/issue-10392.rs",
+"ui/pattern/issue-106552.rs",
+"ui/pattern/issue-11577.rs",
+"ui/pattern/issue-12582.rs",
+"ui/pattern/issue-14221.rs",
+"ui/pattern/issue-15080.rs",
+"ui/pattern/issue-17718-patterns.rs",
+"ui/pattern/issue-22546.rs",
+"ui/pattern/issue-27320.rs",
+"ui/pattern/issue-52240.rs",
+"ui/pattern/issue-6449.rs",
+"ui/pattern/issue-66270-pat-struct-parser-recovery.rs",
+"ui/pattern/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs",
+"ui/pattern/issue-67776-match-same-name-enum-variant-refs.rs",
+"ui/pattern/issue-68393-let-pat-assoc-constant.rs",
+"ui/pattern/issue-72574-1.rs",
+"ui/pattern/issue-72574-2.rs",
+"ui/pattern/issue-74539.rs",
+"ui/pattern/issue-74702.rs",
+"ui/pattern/issue-80186-mut-binding-help-suggestion.rs",
+"ui/pattern/issue-8351-1.rs",
+"ui/pattern/issue-8351-2.rs",
+"ui/pattern/issue-88074-pat-range-type-inference-err.rs",
+"ui/pattern/issue-92074-macro-ice.rs",
+"ui/pattern/issue-95878.rs",
+"ui/pattern/issue-72565.rs",
+"ui/pattern/issue-94866.rs",
+"ui/pattern/issue-106862.rs",
+"ui/pattern/issue-74954.rs",
+"ui/pattern/issue-88074-pat-range-type-inference.rs",
+"ui/pattern/issue-110508.rs",
+"ui/polymorphization/issue-74614.rs",
+"ui/polymorphization/issue-74636.rs",
+"ui/privacy/auxiliary/issue-17718-const-privacy.rs",
+"ui/privacy/auxiliary/issue-57264-1.rs",
+"ui/privacy/auxiliary/issue-57264-2.rs",
+"ui/privacy/auxiliary/issue-75907.rs",
+"ui/privacy/auxiliary/issue-92755.rs",
+"ui/privacy/issue-13641.rs",
+"ui/privacy/issue-17718-const-privacy.rs",
+"ui/privacy/issue-29161.rs",
+"ui/privacy/issue-30079.rs",
+"ui/privacy/issue-46209-private-enum-variant-reexport.rs",
+"ui/privacy/issue-75062-fieldless-tuple-struct.rs",
+"ui/privacy/issue-75906.rs",
+"ui/privacy/issue-75907.rs",
+"ui/privacy/issue-75907_b.rs",
+"ui/privacy/issue-79593.rs",
+"ui/privacy/issue-92755.rs",
+"ui/privacy/issue-111220-2-tuple-struct-fields-projection.rs",
+"ui/privacy/issue-111220-tuple-struct-fields.rs",
+"ui/privacy/issue-57264-1.rs",
+"ui/privacy/issue-57264-2.rs",
+"ui/proc-macro/auxiliary/issue-104884.rs",
+"ui/proc-macro/auxiliary/issue-38586.rs",
+"ui/proc-macro/auxiliary/issue-39889.rs",
+"ui/proc-macro/auxiliary/issue-42708.rs",
+"ui/proc-macro/auxiliary/issue-50061.rs",
+"ui/proc-macro/auxiliary/issue-50493.rs",
+"ui/proc-macro/auxiliary/issue-66286.rs",
+"ui/proc-macro/auxiliary/issue-75801.rs",
+"ui/proc-macro/auxiliary/issue-79242.rs",
+"ui/proc-macro/auxiliary/issue-79825.rs",
+"ui/proc-macro/auxiliary/issue-83510.rs",
+"ui/proc-macro/auxiliary/issue-91800-macro.rs",
+"ui/proc-macro/auxiliary/issue-59191.rs",
+"ui/proc-macro/issue-104884-trait-impl-sugg-err.rs",
+"ui/proc-macro/issue-36935.rs",
+"ui/proc-macro/issue-37788.rs",
+"ui/proc-macro/issue-38586.rs",
+"ui/proc-macro/issue-39889.rs",
+"ui/proc-macro/issue-42708.rs",
+"ui/proc-macro/issue-50061.rs",
+"ui/proc-macro/issue-50493.rs",
+"ui/proc-macro/issue-53481.rs",
+"ui/proc-macro/issue-66286.rs",
+"ui/proc-macro/issue-75801.rs",
+"ui/proc-macro/issue-81543-item-parse-err.rs",
+"ui/proc-macro/issue-83469-global-alloc-invalid-stmt.rs",
+"ui/proc-macro/issue-83510.rs",
+"ui/proc-macro/issue-91800.rs",
+"ui/proc-macro/issue-59191-replace-root-with-fn.rs",
+"ui/proc-macro/issue-73933-procedural-masquerade.rs",
+"ui/proc-macro/issue-75734-pp-paren.rs",
+"ui/proc-macro/issue-75930-derive-cfg.rs",
+"ui/proc-macro/issue-76182-leading-vert-pat.rs",
+"ui/proc-macro/issue-76270-panic-in-libproc-macro.rs",
+"ui/proc-macro/issue-78675-captured-inner-attrs.rs",
+"ui/proc-macro/issue-79148.rs",
+"ui/proc-macro/issue-79242-slow-retokenize-check.rs",
+"ui/proc-macro/issue-79825.rs",
+"ui/proc-macro/issue-80760-empty-stmt.rs",
+"ui/proc-macro/issue-81007-item-attrs.rs",
+"ui/proc-macro/issue-81555.rs",
+"ui/proc-macro/issue-86781-bad-inner-doc.rs",
+"ui/process/issue-13304.rs",
+"ui/process/issue-14456.rs",
+"ui/process/issue-14940.rs",
+"ui/process/issue-16272.rs",
+"ui/process/issue-20091.rs",
+"ui/ptr_ops/issue-80309-safe.rs",
+"ui/ptr_ops/issue-80309.rs",
+"ui/pub/issue-33174-restricted-type-in-public-interface.rs",
+"ui/query-system/issue-83479.rs",
+"ui/range/issue-54505-no-std.rs",
+"ui/range/issue-73553-misinterp-range-literal.rs",
+"ui/range/issue-54505-no-literals.rs",
+"ui/range/issue-54505.rs",
+"ui/reachable/auxiliary/issue-11225-1.rs",
+"ui/reachable/auxiliary/issue-11225-2.rs",
+"ui/reachable/auxiliary/issue-11225-3.rs",
+"ui/reachable/issue-11225-1.rs",
+"ui/reachable/issue-11225-2.rs",
+"ui/reachable/issue-11225-3.rs",
+"ui/reachable/issue-948.rs",
+"ui/recursion/issue-26548-recursion-via-normalize.rs",
+"ui/recursion/issue-38591-non-regular-dropck-recursion.rs",
+"ui/recursion/issue-86784.rs",
+"ui/recursion/issue-83150.rs",
+"ui/recursion/issue-95134.rs",
+"ui/recursion_limit/issue-105700.rs",
+"ui/recursion_limit/issue-40003.rs",
+"ui/regions/issue-101280.rs",
+"ui/regions/issue-102374.rs",
+"ui/regions/issue-102392.rs",
+"ui/regions/issue-12470.rs",
+"ui/regions/issue-26448-1.rs",
+"ui/regions/issue-28848.rs",
+"ui/regions/issue-5243.rs",
+"ui/regions/issue-6157.rs",
+"ui/regions/issue-11612.rs",
+"ui/regions/issue-21520.rs",
+"ui/regions/issue-24085.rs",
+"ui/regions/issue-26448-2.rs",
+"ui/regions/issue-26448-3.rs",
+"ui/regions/issue-56537-closure-uses-region-from-container.rs",
+"ui/regions/issue-72051-member-region-hang.rs",
+"ui/regions/issue-78262.rs",
+"ui/repr/issue-83505-repr-simd.rs",
+"ui/repr/issue-83921-ice.rs",
+"ui/resolve/auxiliary/issue-19452-aux.rs",
+"ui/resolve/auxiliary/issue-21221-3.rs",
+"ui/resolve/auxiliary/issue-21221-4.rs",
+"ui/resolve/auxiliary/issue-30535.rs",
+"ui/resolve/auxiliary/issue-3907.rs",
+"ui/resolve/auxiliary/issue-80079.rs",
+"ui/resolve/auxiliary/issue-112831-aux.rs",
+"ui/resolve/issue-113808-invalid-unused-qualifications-suggestion.rs",
+"ui/resolve/issue-100365.rs",
+"ui/resolve/issue-101749-2.rs",
+"ui/resolve/issue-10200.rs",
+"ui/resolve/issue-102946.rs",
+"ui/resolve/issue-103202.rs",
+"ui/resolve/issue-103474.rs",
+"ui/resolve/issue-104700-inner_scope.rs",
+"ui/resolve/issue-105069.rs",
+"ui/resolve/issue-107563-ambiguous-glob-reexports.rs",
+"ui/resolve/issue-108529.rs",
+"ui/resolve/issue-109250.rs",
+"ui/resolve/issue-12796.rs",
+"ui/resolve/issue-14254.rs",
+"ui/resolve/issue-16058.rs",
+"ui/resolve/issue-17518.rs",
+"ui/resolve/issue-18252.rs",
+"ui/resolve/issue-19452.rs",
+"ui/resolve/issue-21221-1.rs",
+"ui/resolve/issue-21221-2.rs",
+"ui/resolve/issue-21221-3.rs",
+"ui/resolve/issue-21221-4.rs",
+"ui/resolve/issue-22692.rs",
+"ui/resolve/issue-2330.rs",
+"ui/resolve/issue-23305.rs",
+"ui/resolve/issue-2356.rs",
+"ui/resolve/issue-23716.rs",
+"ui/resolve/issue-24968.rs",
+"ui/resolve/issue-26545.rs",
+"ui/resolve/issue-3021-c.rs",
+"ui/resolve/issue-3021.rs",
+"ui/resolve/issue-30535.rs",
+"ui/resolve/issue-3099-a.rs",
+"ui/resolve/issue-3099-b.rs",
+"ui/resolve/issue-31845.rs",
+"ui/resolve/issue-33876.rs",
+"ui/resolve/issue-35675.rs",
+"ui/resolve/issue-3907-2.rs",
+"ui/resolve/issue-3907.rs",
+"ui/resolve/issue-39226.rs",
+"ui/resolve/issue-39559-2.rs",
+"ui/resolve/issue-39559.rs",
+"ui/resolve/issue-42944.rs",
+"ui/resolve/issue-49074.rs",
+"ui/resolve/issue-5035-2.rs",
+"ui/resolve/issue-5035.rs",
+"ui/resolve/issue-50599.rs",
+"ui/resolve/issue-5099.rs",
+"ui/resolve/issue-54379.rs",
+"ui/resolve/issue-55673.rs",
+"ui/resolve/issue-5927.rs",
+"ui/resolve/issue-60057.rs",
+"ui/resolve/issue-65025-extern-static-parent-generics.rs",
+"ui/resolve/issue-65035-static-with-parent-generics.rs",
+"ui/resolve/issue-6702.rs",
+"ui/resolve/issue-69401-trait-fn-no-body-ty-local.rs",
+"ui/resolve/issue-73427.rs",
+"ui/resolve/issue-80079.rs",
+"ui/resolve/issue-81508.rs",
+"ui/resolve/issue-82156.rs",
+"ui/resolve/issue-82865.rs",
+"ui/resolve/issue-85348.rs",
+"ui/resolve/issue-88472.rs",
+"ui/resolve/issue-90113.rs",
+"ui/resolve/issue-109153.rs",
+"ui/resolve/issue-101749.rs",
+"ui/resolve/issue-111312.rs",
+"ui/resolve/issue-111727.rs",
+"ui/resolve/issue-112472-multi-generics-suggestion.rs",
+"ui/resolve/issue-112831.rs",
+"ui/resolve/issue-57523.rs",
+"ui/resolve/issue-70736-async-fn-no-body-def-collector.rs",
+"ui/resolve/issue-85671.rs",
+"ui/return/issue-82612-return-mutable-reference.rs",
+"ui/return/issue-64620.rs",
+"ui/return/issue-86188-return-not-in-fn-body.rs",
+"ui/rfcs/rfc-1937-termination-trait/issue-103052-1.rs",
+"ui/rfcs/rfc-1937-termination-trait/issue-103052-2.rs",
+"ui/rfcs/rfc-2005-default-binding-mode/issue-44912-or.rs",
+"ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-main.rs",
+"ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-start.rs",
+"ui/rfcs/rfc-2396-target_feature-11/issue-99876.rs",
+"ui/rfcs/rfc-2396-target_feature-11/issue-108655-inline-always-closure.rs",
+"ui/rfcs/rfc-2528-type-changing-struct-update/issue-92010-trait-bound-not-satisfied.rs",
+"ui/rfcs/rfc-2528-type-changing-struct-update/issue-96878.rs",
+"ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-61188-match-slice-forbidden-without-eq.rs",
+"ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.rs",
+"ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-63479-match-fnptr.rs",
+"ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-6804.rs",
+"ui/rfcs/rfc-2008-non-exhaustive/uninhabited/issue-65157-repeated-match-arm.rs",
+"ui/rfcs/rfc-2093-infer-outlives/issue-54467.rs",
+"ui/rfcs/rfc-2497-if-let-chains/issue-93150.rs",
+"ui/rfcs/rfc-2497-if-let-chains/issue-88498.rs",
+"ui/rfcs/rfc-2497-if-let-chains/issue-90722.rs",
+"ui/rfcs/rfc-2497-if-let-chains/issue-92145.rs",
+"ui/rfcs/rfc-2497-if-let-chains/issue-99938.rs",
+"ui/rfcs/rfc-2565-param-attrs/issue-64682-dropping-first-attrs-in-impl-fns.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-102156.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-102985.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-79450.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-88155.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-90052.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/specialization/issue-95186-specialize-on-tilde-const.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/specialization/issue-95187-same-trait-bound-different-constness.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-100222.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-103677.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-92111.rs",
+"ui/rfcs/rfc-2632-const-trait-impl/issue-92230-wf-super-trait-env.rs",
+"ui/rust-2018/uniform-paths/auxiliary/issue-55779-extern-trait.rs",
+"ui/rust-2018/uniform-paths/auxiliary/issue-56596-2.rs",
+"ui/rust-2018/uniform-paths/auxiliary/issue-56596.rs",
+"ui/rust-2018/uniform-paths/auxiliary/issue-87932-a.rs",
+"ui/rust-2018/uniform-paths/issue-54253.rs",
+"ui/rust-2018/uniform-paths/issue-55779.rs",
+"ui/rust-2018/uniform-paths/issue-56596-2.rs",
+"ui/rust-2018/uniform-paths/issue-56596.rs",
+"ui/rust-2018/uniform-paths/issue-87932.rs",
+"ui/rust-2018/issue-51008-1.rs",
+"ui/rust-2018/issue-51008.rs",
+"ui/rust-2018/issue-52202-use-suggestions.rs",
+"ui/rust-2018/issue-54006.rs",
+"ui/rust-2018/issue-54400-unused-extern-crate-attr-span.rs",
+"ui/sanitize/issue-111184-generator-witness.rs",
+"ui/sanitize/issue-72154-lifetime-markers.rs",
+"ui/self/issue-61882-2.rs",
+"ui/self/issue-61882.rs",
+"ui/simd/intrinsic/issue-85855.rs",
+"ui/simd/issue-17170.rs",
+"ui/simd/issue-32947.rs",
+"ui/simd/issue-39720.rs",
+"ui/simd/issue-85915-simd-ptrs.rs",
+"ui/simd/issue-89193.rs",
+"ui/simd/issue-105439.rs",
+"ui/single-use-lifetime/issue-104440.rs",
+"ui/single-use-lifetime/issue-107998.rs",
+"ui/span/issue28498-reject-ex1.rs",
+"ui/span/issue28498-reject-lifetime-param.rs",
+"ui/span/issue28498-reject-passed-to-fn.rs",
+"ui/span/issue28498-reject-trait-bound.rs",
+"ui/span/issue-11925.rs",
+"ui/span/issue-23338-locals-die-before-temps-of-body.rs",
+"ui/span/issue-23729.rs",
+"ui/span/issue-23827.rs",
+"ui/span/issue-24356.rs",
+"ui/span/issue-24805-dropck-child-has-items-via-parent.rs",
+"ui/span/issue-24805-dropck-trait-has-items.rs",
+"ui/span/issue-24895-copy-clone-dropck.rs",
+"ui/span/issue-25199.rs",
+"ui/span/issue-26656.rs",
+"ui/span/issue-27522.rs",
+"ui/span/issue-29106.rs",
+"ui/span/issue-29595.rs",
+"ui/span/issue-33884.rs",
+"ui/span/issue-34264.rs",
+"ui/span/issue-35987.rs",
+"ui/span/issue-36537.rs",
+"ui/span/issue-37767.rs",
+"ui/span/issue-39018.rs",
+"ui/span/issue-39698.rs",
+"ui/span/issue-40157.rs",
+"ui/span/issue-43927-non-ADT-derive.rs",
+"ui/span/issue-81800.rs",
+"ui/span/issue-107353.rs",
+"ui/span/issue-15480.rs",
+"ui/span/issue-24690.rs",
+"ui/span/issue-42234-unknown-receiver-type.rs",
+"ui/span/issue-71363.rs",
+"ui/specialization/min_specialization/issue-79224.rs",
+"ui/specialization/issue-111232.rs",
+"ui/specialization/issue-33017.rs",
+"ui/specialization/issue-38091-2.rs",
+"ui/specialization/issue-38091.rs",
+"ui/specialization/issue-39448.rs",
+"ui/specialization/issue-44861.rs",
+"ui/specialization/issue-50452-fail.rs",
+"ui/specialization/issue-50452.rs",
+"ui/specialization/issue-51892.rs",
+"ui/specialization/issue-52050.rs",
+"ui/specialization/issue-59435.rs",
+"ui/specialization/issue-68830-spurious-diagnostics.rs",
+"ui/specialization/issue-35376.rs",
+"ui/specialization/issue-36804.rs",
+"ui/specialization/issue-39618.rs",
+"ui/specialization/issue-40582.rs",
+"ui/specialization/issue-43037.rs",
+"ui/specialization/issue-45814.rs",
+"ui/specialization/issue-63716-parse-async.rs",
+"ui/specialization/issue-70442.rs",
+"ui/stability-attribute/issue-106589.rs",
+"ui/stability-attribute/issue-109177.rs",
+"ui/stability-attribute/issue-28075.rs",
+"ui/stability-attribute/issue-28388-3.rs",
+"ui/stability-attribute/issue-99286-stable-intrinsics.rs",
+"ui/static/auxiliary/issue_24843.rs",
+"ui/static/issue-18118-2.rs",
+"ui/static/issue-18118.rs",
+"ui/static/issue-34194.rs",
+"ui/static/issue-5216.rs",
+"ui/static/issue-24843.rs",
+"ui/statics/issue-15261.rs",
+"ui/statics/issue-17233.rs",
+"ui/statics/issue-17718-static-sync.rs",
+"ui/statics/issue-17718-static-unsafe-interior.rs",
+"ui/statics/issue-44373.rs",
+"ui/statics/issue-14227.rs",
+"ui/statics/issue-44373-2.rs",
+"ui/statics/issue-91050-1.rs",
+"ui/statics/issue-91050-2.rs",
+"ui/std/issue-15149.rs",
+"ui/std/issue-81357-unsound-file-methods.rs",
+"ui/stdlib-unit-tests/issue-21058.rs",
+"ui/structs-enums/struct-rec/issue-74224.rs",
+"ui/structs-enums/struct-rec/issue-84611.rs",
+"ui/structs-enums/issue-1701.rs",
+"ui/structs-enums/issue-2718-a.rs",
+"ui/structs-enums/issue-38002.rs",
+"ui/structs-enums/issue-50731.rs",
+"ui/structs-enums/issue-3008-1.rs",
+"ui/structs-enums/issue-3008-2.rs",
+"ui/structs-enums/issue-3008-3.rs",
+"ui/structs-enums/issue-103869.rs",
+"ui/structs/issue-80853.rs",
+"ui/suggestions/auxiliary/issue-61963-1.rs",
+"ui/suggestions/auxiliary/issue-61963.rs",
+"ui/suggestions/auxiliary/issue-81839.rs",
+"ui/suggestions/lifetimes/issue-105544.rs",
+"ui/suggestions/issue-101421.rs",
+"ui/suggestions/issue-101465.rs",
+"ui/suggestions/issue-101623.rs",
+"ui/suggestions/issue-101984.rs",
+"ui/suggestions/issue-102354.rs",
+"ui/suggestions/issue-102892.rs",
+"ui/suggestions/issue-103112.rs",
+"ui/suggestions/issue-104086-suggest-let.rs",
+"ui/suggestions/issue-104287.rs",
+"ui/suggestions/issue-104327.rs",
+"ui/suggestions/issue-104328.rs",
+"ui/suggestions/issue-105226.rs",
+"ui/suggestions/issue-105494.rs",
+"ui/suggestions/issue-105645.rs",
+"ui/suggestions/issue-106443-sugg-clone-for-arg.rs",
+"ui/suggestions/issue-106443-sugg-clone-for-bound.rs",
+"ui/suggestions/issue-109291.rs",
+"ui/suggestions/issue-109396.rs",
+"ui/suggestions/issue-109436.rs",
+"ui/suggestions/issue-109854.rs",
+"ui/suggestions/issue-21673.rs",
+"ui/suggestions/issue-51055-missing-semicolon-between-call-and-tuple.rs",
+"ui/suggestions/issue-61963.rs",
+"ui/suggestions/issue-62843.rs",
+"ui/suggestions/issue-64252-self-type.rs",
+"ui/suggestions/issue-66968-suggest-sorted-words.rs",
+"ui/suggestions/issue-68049-1.rs",
+"ui/suggestions/issue-68049-2.rs",
+"ui/suggestions/issue-71394-no-from-impl.rs",
+"ui/suggestions/issue-81098.rs",
+"ui/suggestions/issue-82566-1.rs",
+"ui/suggestions/issue-82566-2.rs",
+"ui/suggestions/issue-84592.rs",
+"ui/suggestions/issue-84700.rs",
+"ui/suggestions/issue-84973-2.rs",
+"ui/suggestions/issue-84973-blacklist.rs",
+"ui/suggestions/issue-84973-negative.rs",
+"ui/suggestions/issue-84973.rs",
+"ui/suggestions/issue-85347.rs",
+"ui/suggestions/issue-85943-no-suggest-unsized-indirection-in-where-clause.rs",
+"ui/suggestions/issue-85945-check-where-clause-before-suggesting-unsized.rs",
+"ui/suggestions/issue-86100-tuple-paren-comma.rs",
+"ui/suggestions/issue-88730.rs",
+"ui/suggestions/issue-89064.rs",
+"ui/suggestions/issue-89333.rs",
+"ui/suggestions/issue-90974.rs",
+"ui/suggestions/issue-94171.rs",
+"ui/suggestions/issue-96223.rs",
+"ui/suggestions/issue-97760.rs",
+"ui/suggestions/issue-98500.rs",
+"ui/suggestions/issue-99080.rs",
+"ui/suggestions/issue-99240-2.rs",
+"ui/suggestions/issue-99240.rs",
+"ui/suggestions/issue-99597.rs",
+"ui/suggestions/issue-103646.rs",
+"ui/suggestions/issue-88696.rs",
+"ui/suggestions/issue-101065.rs",
+"ui/suggestions/issue-104961.rs",
+"ui/suggestions/issue-105761-suggest-self-for-closure.rs",
+"ui/suggestions/issue-107860.rs",
+"ui/suggestions/issue-108470.rs",
+"ui/suggestions/issue-52820.rs",
+"ui/suggestions/issue-53692.rs",
+"ui/suggestions/issue-57672.rs",
+"ui/suggestions/issue-59819.rs",
+"ui/suggestions/issue-61226.rs",
+"ui/suggestions/issue-72766.rs",
+"ui/suggestions/issue-79843-impl-trait-with-missing-bounds-on-async-fn.rs",
+"ui/suggestions/issue-81839.rs",
+"ui/suggestions/issue-82361.rs",
+"ui/suggestions/issue-83892.rs",
+"ui/suggestions/issue-83943.rs",
+"ui/suggestions/issue-86667.rs",
+"ui/suggestions/issue-90213-expected-boxfuture-self-ice.rs",
+"ui/suggestions/issue-96555.rs",
+"ui/suggestions/issue-97677.rs",
+"ui/suggestions/issue-97704.rs",
+"ui/suggestions/issue-102972.rs",
+"ui/suggestions/issue-109991.rs",
+"ui/suggestions/issue-112590-suggest-import.rs",
+"ui/suggestions/issue-89640.rs",
+"ui/symbol-names/issue-53912.rs",
+"ui/symbol-names/issue-60925.rs",
+"ui/symbol-names/issue-75326.rs",
+"ui/symbol-names/issue-76365.rs",
+"ui/test-attrs/custom-test-frameworks/issue-107454.rs",
+"ui/test-attrs/issue-109816.rs",
+"ui/test-attrs/issue-12997-1.rs",
+"ui/test-attrs/issue-12997-2.rs",
+"ui/test-attrs/issue-16597-empty.rs",
+"ui/test-attrs/issue-16597.rs",
+"ui/test-attrs/issue-20823.rs",
+"ui/test-attrs/issue-34932.rs",
+"ui/test-attrs/issue-36768.rs",
+"ui/test-attrs/issue-52557.rs",
+"ui/test-attrs/issue-53675-a-test-called-panic.rs",
+"ui/threads-sendsync/issue-24313.rs",
+"ui/threads-sendsync/issue-29488.rs",
+"ui/threads-sendsync/issue-43733-2.rs",
+"ui/threads-sendsync/issue-4446.rs",
+"ui/threads-sendsync/issue-4448.rs",
+"ui/threads-sendsync/issue-8827.rs",
+"ui/threads-sendsync/issue-9396.rs",
+"ui/threads-sendsync/issue-43733.rs",
+"ui/trait-bounds/issue-75961.rs",
+"ui/trait-bounds/issue-93008.rs",
+"ui/trait-bounds/issue-94680.rs",
+"ui/trait-bounds/issue-94999.rs",
+"ui/trait-bounds/issue-95640.rs",
+"ui/traits/alias/issue-108072-unmet-trait-alias-bound.rs",
+"ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.rs",
+"ui/traits/alias/issue-83613.rs",
+"ui/traits/alias/issue-107747-do-not-assemble-supertraits.rs",
+"ui/traits/alias/issue-60021-assoc-method-resolve.rs",
+"ui/traits/alias/issue-60755.rs",
+"ui/traits/alias/issue-72415-assoc-const-resolve.rs",
+"ui/traits/alias/issue-75983.rs",
+"ui/traits/associated_type_bound/issue-51446.rs",
+"ui/traits/auxiliary/issue_89119_intercrate_caching.rs",
+"ui/traits/new-solver/coherence/issue-102048.rs",
+"ui/traits/object/issue-44454-1.rs",
+"ui/traits/object/issue-44454-2.rs",
+"ui/traits/object/issue-44454-3.rs",
+"ui/traits/object/issue-33140-traitobject-crate.rs",
+"ui/traits/suggest-deferences/issue-39029.rs",
+"ui/traits/suggest-deferences/issue-62530.rs",
+"ui/traits/trait-upcasting/issue-11515.rs",
+"ui/traits/trait-upcasting/issue-11515-upcast-fn_mut-fn.rs",
+"ui/traits/vtable/issue-97381.rs",
+"ui/traits/vtable/issue-91807.rs",
+"ui/traits/issue-102989.rs",
+"ui/traits/issue-103563.rs",
+"ui/traits/issue-104322.rs",
+"ui/traits/issue-106072.rs",
+"ui/traits/issue-18400.rs",
+"ui/traits/issue-18412.rs",
+"ui/traits/issue-20692.rs",
+"ui/traits/issue-22019.rs",
+"ui/traits/issue-22110.rs",
+"ui/traits/issue-22384.rs",
+"ui/traits/issue-22655.rs",
+"ui/traits/issue-23003.rs",
+"ui/traits/issue-23825.rs",
+"ui/traits/issue-24010.rs",
+"ui/traits/issue-26339.rs",
+"ui/traits/issue-28576.rs",
+"ui/traits/issue-32963.rs",
+"ui/traits/issue-33140-hack-boundaries.rs",
+"ui/traits/issue-33140.rs",
+"ui/traits/issue-35869.rs",
+"ui/traits/issue-3683.rs",
+"ui/traits/issue-38033.rs",
+"ui/traits/issue-38404.rs",
+"ui/traits/issue-38604.rs",
+"ui/traits/issue-3973.rs",
+"ui/traits/issue-4107.rs",
+"ui/traits/issue-43132.rs",
+"ui/traits/issue-43784-supertrait.rs",
+"ui/traits/issue-50480.rs",
+"ui/traits/issue-52893.rs",
+"ui/traits/issue-56202.rs",
+"ui/traits/issue-56488.rs",
+"ui/traits/issue-59029-1.rs",
+"ui/traits/issue-59029-2.rs",
+"ui/traits/issue-6128.rs",
+"ui/traits/issue-6334.rs",
+"ui/traits/issue-65284-suggest-generic-trait-bound.rs",
+"ui/traits/issue-65673.rs",
+"ui/traits/issue-68295.rs",
+"ui/traits/issue-7013.rs",
+"ui/traits/issue-71036.rs",
+"ui/traits/issue-71136.rs",
+"ui/traits/issue-72410.rs",
+"ui/traits/issue-75627.rs",
+"ui/traits/issue-77982.rs",
+"ui/traits/issue-78372.rs",
+"ui/traits/issue-79458.rs",
+"ui/traits/issue-8153.rs",
+"ui/traits/issue-85735.rs",
+"ui/traits/issue-87558.rs",
+"ui/traits/issue-91594.rs",
+"ui/traits/issue-9394-inherited-calls.rs",
+"ui/traits/issue-97576.rs",
+"ui/traits/issue-99875.rs",
+"ui/traits/issue-105231.rs",
+"ui/traits/issue-83538-tainted-cache-after-cycle.rs",
+"ui/traits/issue-23003-overflow.rs",
+"ui/traits/issue-70944.rs",
+"ui/traits/issue-72455.rs",
+"ui/traits/issue-78632.rs",
+"ui/traits/issue-82830.rs",
+"ui/traits/issue-84399-bad-fresh-caching.rs",
+"ui/traits/issue-85360-eval-obligation-ice.rs",
+"ui/traits/issue-89119.rs",
+"ui/traits/issue-90195-2.rs",
+"ui/traits/issue-90195.rs",
+"ui/traits/issue-90662-projection-caching.rs",
+"ui/traits/issue-91949-hangs-on-recursion.rs",
+"ui/traits/issue-92292.rs",
+"ui/traits/issue-95311.rs",
+"ui/traits/issue-95898.rs",
+"ui/traits/issue-96664.rs",
+"ui/traits/issue-96665.rs",
+"ui/traits/issue-97695-double-trivial-bound.rs",
+"ui/transmutability/arrays/issue-103783-array-length.rs",
+"ui/transmutability/issue-101739-1.rs",
+"ui/transmutability/issue-101739-2.rs",
+"ui/transmutability/issue-110467.rs",
+"ui/transmutability/issue-110892.rs",
+"ui/trivial-bounds/issue-73021-impossible-inline.rs",
+"ui/try-block/issue-45124.rs",
+"ui/type-alias-enum-variants/issue-57866.rs",
+"ui/type-alias-enum-variants/issue-61801-path-pattern-can-infer.rs",
+"ui/type-alias-enum-variants/issue-63151-dead-code-lint-fields-in-patterns.rs",
+"ui/type-alias-impl-trait/issue-52843-closure-constrain.rs",
+"ui/type-alias-impl-trait/issue-52843.rs",
+"ui/type-alias-impl-trait/issue-53092-2.rs",
+"ui/type-alias-impl-trait/issue-53092.rs",
+"ui/type-alias-impl-trait/issue-53096.rs",
+"ui/type-alias-impl-trait/issue-53598.rs",
+"ui/type-alias-impl-trait/issue-57700.rs",
+"ui/type-alias-impl-trait/issue-58887.rs",
+"ui/type-alias-impl-trait/issue-60371.rs",
+"ui/type-alias-impl-trait/issue-60407.rs",
+"ui/type-alias-impl-trait/issue-63279.rs",
+"ui/type-alias-impl-trait/issue-65384.rs",
+"ui/type-alias-impl-trait/issue-65918.rs",
+"ui/type-alias-impl-trait/issue-74244.rs",
+"ui/type-alias-impl-trait/issue-74280.rs",
+"ui/type-alias-impl-trait/issue-74761-2.rs",
+"ui/type-alias-impl-trait/issue-74761.rs",
+"ui/type-alias-impl-trait/issue-84660-unsoundness.rs",
+"ui/type-alias-impl-trait/issue-90400-1.rs",
+"ui/type-alias-impl-trait/issue-90400-2.rs",
+"ui/type-alias-impl-trait/issue-94429.rs",
+"ui/type-alias-impl-trait/issue-96572-unconstrained-mismatch.rs",
+"ui/type-alias-impl-trait/issue-98608.rs",
+"ui/type-alias-impl-trait/issue-101750.rs",
+"ui/type-alias-impl-trait/issue-104817.rs",
+"ui/type-alias-impl-trait/issue-53398-cyclic-types.rs",
+"ui/type-alias-impl-trait/issue-55099-lifetime-inference.rs",
+"ui/type-alias-impl-trait/issue-57188-associate-impl-capture.rs",
+"ui/type-alias-impl-trait/issue-57611-trait-alias.rs",
+"ui/type-alias-impl-trait/issue-57807-associated-type.rs",
+"ui/type-alias-impl-trait/issue-58662-generator-with-lifetime.rs",
+"ui/type-alias-impl-trait/issue-58662-simplified.rs",
+"ui/type-alias-impl-trait/issue-58951-2.rs",
+"ui/type-alias-impl-trait/issue-58951.rs",
+"ui/type-alias-impl-trait/issue-60564-working.rs",
+"ui/type-alias-impl-trait/issue-60662.rs",
+"ui/type-alias-impl-trait/issue-62000-associate-impl-trait-lifetimes.rs",
+"ui/type-alias-impl-trait/issue-63355.rs",
+"ui/type-alias-impl-trait/issue-63677-type-alias-coherence.rs",
+"ui/type-alias-impl-trait/issue-66580-closure-coherence.rs",
+"ui/type-alias-impl-trait/issue-67844-nested-opaque.rs",
+"ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-ok.rs",
+"ui/type-alias-impl-trait/issue-69323.rs",
+"ui/type-alias-impl-trait/issue-72793.rs",
+"ui/type-alias-impl-trait/issue-76202-trait-impl-for-tait.rs",
+"ui/type-alias-impl-trait/issue-78450.rs",
+"ui/type-alias-impl-trait/issue-84660-trait-impl-for-tait.rs",
+"ui/type-alias-impl-trait/issue-87455-static-lifetime-ice.rs",
+"ui/type-alias-impl-trait/issue-89686.rs",
+"ui/type-alias-impl-trait/issue-89952.rs",
+"ui/type-alias-impl-trait/issue-93411.rs",
+"ui/type-alias-impl-trait/issue-96572-unconstrained.rs",
+"ui/type-alias-impl-trait/issue-98604.rs",
+"ui/type-alias-impl-trait/issue-109054.rs",
+"ui/type-alias-impl-trait/issue-53678-generator-and-const-fn.rs",
+"ui/type-alias-impl-trait/issue-57961.rs",
+"ui/type-alias-impl-trait/issue-60564.rs",
+"ui/type-alias-impl-trait/issue-63263-closure-return.rs",
+"ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs",
+"ui/type-alias-impl-trait/issue-68368-non-defining-use-2.rs",
+"ui/type-alias-impl-trait/issue-68368-non-defining-use.rs",
+"ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.rs",
+"ui/type-alias-impl-trait/issue-70121.rs",
+"ui/type-alias-impl-trait/issue-77179.rs",
+"ui/type-alias/issue-62263-self-in-atb.rs",
+"ui/type-alias/issue-62305-self-assoc-ty.rs",
+"ui/type-alias/issue-62364-self-ty-arg.rs",
+"ui/type-alias/issue-14933.rs",
+"ui/type-alias/issue-37515.rs",
+"ui/type-inference/issue-30225.rs",
+"ui/type-inference/issue-113283-alllocator-trait-eq.rs",
+"ui/type/ascription/issue-34255-1.rs",
+"ui/type/ascription/issue-47666.rs",
+"ui/type/ascription/issue-54516.rs",
+"ui/type/ascription/issue-60933.rs",
+"ui/type/type-check/issue-22897.rs",
+"ui/type/type-check/issue-40294.rs",
+"ui/type/type-check/issue-41314.rs",
+"ui/type/type-check/issue-67273-assignment-match-prior-arm-bool-expected-unit.rs",
+"ui/type/type-check/issue-88577-check-fn-with-more-than-65535-arguments.rs",
+"ui/type/issue-100584.rs",
+"ui/type/issue-101866.rs",
+"ui/type/issue-102598.rs",
+"ui/type/issue-103271.rs",
+"ui/type/issue-58355.rs",
+"ui/type/issue-67690-type-alias-bound-diagnostic-crash.rs",
+"ui/type/issue-91268.rs",
+"ui/type/issue-94187-verbose-type-name.rs",
+"ui/typeck/auxiliary/issue-36708.rs",
+"ui/typeck/auxiliary/issue-81943-lib.rs",
+"ui/typeck/issue-100246.rs",
+"ui/typeck/issue-100285.rs",
+"ui/typeck/issue-103899.rs",
+"ui/typeck/issue-10401.rs",
+"ui/typeck/issue-104513-ice.rs",
+"ui/typeck/issue-104582.rs",
+"ui/typeck/issue-105946.rs",
+"ui/typeck/issue-107087.rs",
+"ui/typeck/issue-10969.rs",
+"ui/typeck/issue-110052.rs",
+"ui/typeck/issue-13853-2.rs",
+"ui/typeck/issue-13853-5.rs",
+"ui/typeck/issue-13853.rs",
+"ui/typeck/issue-18937-1.rs",
+"ui/typeck/issue-18937.rs",
+"ui/typeck/issue-29124.rs",
+"ui/typeck/issue-31173.rs",
+"ui/typeck/issue-33575.rs",
+"ui/typeck/issue-36708.rs",
+"ui/typeck/issue-43189.rs",
+"ui/typeck/issue-46112.rs",
+"ui/typeck/issue-50687-ice-on-borrow.rs",
+"ui/typeck/issue-52082-type-param-shadows-existing-type.rs",
+"ui/typeck/issue-53712.rs",
+"ui/typeck/issue-57404.rs",
+"ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.rs",
+"ui/typeck/issue-65611.rs",
+"ui/typeck/issue-67971.rs",
+"ui/typeck/issue-69378-ice-on-invalid-type-node-after-recovery.rs",
+"ui/typeck/issue-74086.rs",
+"ui/typeck/issue-75883.rs",
+"ui/typeck/issue-75889.rs",
+"ui/typeck/issue-7813.rs",
+"ui/typeck/issue-79040.rs",
+"ui/typeck/issue-80779.rs",
+"ui/typeck/issue-81293.rs",
+"ui/typeck/issue-81885.rs",
+"ui/typeck/issue-81943.rs",
+"ui/typeck/issue-83621-placeholder-static-in-extern.rs",
+"ui/typeck/issue-83693.rs",
+"ui/typeck/issue-84160.rs",
+"ui/typeck/issue-84768.rs",
+"ui/typeck/issue-84831.rs",
+"ui/typeck/issue-87771-ice-assign-assign-to-bool.rs",
+"ui/typeck/issue-87872-missing-inaccessible-field-literal.rs",
+"ui/typeck/issue-87872-missing-inaccessible-field-pattern.rs",
+"ui/typeck/issue-88609.rs",
+"ui/typeck/issue-88643.rs",
+"ui/typeck/issue-88844.rs",
+"ui/typeck/issue-89275.rs",
+"ui/typeck/issue-89806.rs",
+"ui/typeck/issue-90101.rs",
+"ui/typeck/issue-90164.rs",
+"ui/typeck/issue-90319.rs",
+"ui/typeck/issue-90804-incorrect-reference-suggestion.rs",
+"ui/typeck/issue-91267.rs",
+"ui/typeck/issue-91450-inner-ty-error.rs",
+"ui/typeck/issue-92481.rs",
+"ui/typeck/issue-93486.rs",
+"ui/typeck/issue-96530.rs",
+"ui/typeck/issue-96738.rs",
+"ui/typeck/issue-98260.rs",
+"ui/typeck/issue-98982.rs",
+"ui/typeck/issue-106929.rs",
+"ui/typeck/issue-112385-while-assign-lhs-place-expr-ice.rs",
+"ui/typeck/issue-1871.rs",
+"ui/typeck/issue-2063.rs",
+"ui/typeck/issue-100164.rs",
+"ui/typeck/issue-104510-ice.rs",
+"ui/typeck/issue-107775.rs",
+"ui/typeck/issue-112252-ptr-arithmetics-help.rs",
+"ui/typeck/issue-2063-resource.rs",
+"ui/typeck/issue-22375.rs",
+"ui/typeck/issue-55810-must-typeck-match-pats-before-guards.rs",
+"ui/typeck/issue-61711-once-caused-rustc-inf-loop.rs",
+"ui/typeck/issue-68590-reborrow-through-derefmut.rs",
+"ui/typeck/issue-72225-call-fnmut-through-derefmut.rs",
+"ui/typeck/issue-73592-borrow_mut-through-deref.rs",
+"ui/typeck/issue-74933.rs",
+"ui/typeck/issue-80207-unsized-return.rs",
+"ui/typeck/issue-82772.rs",
+"ui/typeck/issue-88803-call-expr-method.rs",
+"ui/typeck/issue-89044-wrapped-expr-method.rs",
+"ui/typeck/issue-89856.rs",
+"ui/typeck/issue-89935.rs",
+"ui/typeck/issue-90027-async-fn-return-suggestion.rs",
+"ui/typeck/issue-90483-inaccessible-field-adjustment.rs",
+"ui/typeck/issue-91210-ptr-method.rs",
+"ui/typeck/issue-91328.rs",
+"ui/typeck/issue-91334.rs",
+"ui/typeck/issue-91633.rs",
+"ui/typeck/issue-86721-return-expr-ice.rs",
+"ui/typeof/issue-100183.rs",
+"ui/typeof/issue-29184.rs",
+"ui/typeof/issue-42060.rs",
+"ui/unboxed-closures/issue-18652.rs",
+"ui/unboxed-closures/issue-18661.rs",
+"ui/unboxed-closures/issue-30906.rs",
+"ui/unboxed-closures/issue-53448.rs",
+"ui/underscore-imports/issue-110164.rs",
+"ui/uniform-paths/auxiliary/issue-53691.rs",
+"ui/uniform-paths/issue-53691.rs",
+"ui/uninhabited/issue-107505.rs",
+"ui/union/issue-41073.rs",
+"ui/union/issue-81199.rs",
+"ui/union/issue-99375.rs",
+"ui/unsafe/auxiliary/issue-106126.rs",
+"ui/unsafe/issue-106126-good-path-bug.rs",
+"ui/unsafe/issue-3080.rs",
+"ui/unsafe/issue-45087-unreachable-unsafe.rs",
+"ui/unsafe/issue-45107-unnecessary-unsafe-in-closure.rs",
+"ui/unsafe/issue-47412.rs",
+"ui/unsafe/issue-85435-unsafe-op-in-let-under-unsafe-under-closure.rs",
+"ui/unsafe/issue-87414-query-cycle.rs",
+"ui/unsized-locals/issue-30276-feature-flagged.rs",
+"ui/unsized-locals/issue-30276.rs",
+"ui/unsized-locals/issue-50940-with-feature.rs",
+"ui/unsized-locals/issue-50940.rs",
+"ui/unsized-locals/issue-67981.rs",
+"ui/unsized/issue-30355.rs",
+"ui/unsized/issue-75707.rs",
+"ui/unsized/issue-91801.rs",
+"ui/unsized/issue-91803.rs",
+"ui/unsized/issue-40231-1.rs",
+"ui/unsized/issue-40231-2.rs",
+"ui/unsized/issue-71659.rs",
+"ui/unsized/issue-75899-but-gats.rs",
+"ui/unsized/issue-75899.rs",
+"ui/unsized/issue-97732.rs",
+"ui/use/issue-18986.rs",
+"ui/use/issue-60976-extern-use-primitive-type.rs",
+"ui/wf/issue-103573.rs",
+"ui/wf/issue-110157.rs",
+"ui/wf/issue-87495.rs",
+"ui/wf/issue-95665.rs",
+"ui/wf/issue-96810.rs",
+"ui/wf/issue-48638.rs",
+"ui/where-clauses/issue-50825-1.rs",
+"ui/where-clauses/issue-50825.rs",
+"ui/issues-71798.rs",
+"ui/issue-11881.rs",
+"ui/issue-13560.rs",
+"ui/issue-16822.rs",
+"ui/issue-18502.rs",
+"ui/issue-2804.rs",
+"ui/higher-ranked/trait-bounds/issue-30786.rs",
+"ui/higher-ranked/trait-bounds/issue-36139-normalize-closure-sig.rs",
+"ui/higher-ranked/trait-bounds/issue-39292.rs",
+"ui/higher-ranked/trait-bounds/issue-46989.rs",
+"ui/higher-ranked/trait-bounds/issue-58451.rs",
+"ui/higher-ranked/trait-bounds/issue-59311.rs",
+"ui/higher-ranked/trait-bounds/issue-62203-hrtb-ice.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-3.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-71955.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-89118.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90950.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-44005.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-56556.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-1.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-2.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-4.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-5.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-6.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-70120.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-74261.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-76956.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-80706.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-80956.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-81809.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-89436.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90612.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90638.rs",
+"ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90875.rs",
+"ui/higher-ranked/trait-bounds/issue-100689.rs",
+"ui/higher-ranked/trait-bounds/issue-102899.rs",
+"ui/higher-ranked/trait-bounds/issue-42114.rs",
+"ui/higher-ranked/trait-bounds/issue-43623.rs",
+"ui/higher-ranked/trait-bounds/issue-57639.rs",
+"ui/higher-ranked/trait-bounds/issue-60283.rs",
+"ui/higher-ranked/trait-bounds/issue-88446.rs",
+"ui/higher-ranked/trait-bounds/issue-88586-hr-self-outlives-in-trait-def.rs",
+"ui/higher-ranked/trait-bounds/issue-90177.rs",
+"ui/higher-ranked/trait-bounds/issue-95034.rs",
+"ui/higher-ranked/trait-bounds/issue-95230.rs",
+"ui/issue-76387-llvm-miscompile.rs",
+"ui/issue-15924.rs",
+"ui/issue-24106.rs",
+"ui-fulldeps/plugin/auxiliary/issue-40001-plugin.rs",
+"ui-fulldeps/plugin/issue-40001.rs",
+"ui-fulldeps/plugin/issue-15778-fail.rs",
+]
\ No newline at end of file
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index c3a63952841..f9a90bf3a00 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -3,14 +3,16 @@
 //! - there are no stray `.stderr` files
 
 use ignore::Walk;
-use std::collections::HashMap;
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs;
 use std::path::{Path, PathBuf};
 
 const ENTRY_LIMIT: usize = 900;
 // FIXME: The following limits should be reduced eventually.
-const ISSUES_ENTRY_LIMIT: usize = 1894;
+const ISSUES_ENTRY_LIMIT: usize = 1893;
 const ROOT_ENTRY_LIMIT: usize = 870;
 
 const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
@@ -88,6 +90,12 @@ fn check_entries(tests_path: &Path, bad: &mut bool) {
 
 pub fn check(path: &Path, bad: &mut bool) {
     check_entries(&path, bad);
+
+    // the list of files in ui tests that are allowed to start with `issue-XXXX`
+    let mut allowed_issue_filenames: HashSet<String> = HashSet::from(
+        include!("issues.txt").map(|path| path.replace("/", std::path::MAIN_SEPARATOR_STR)),
+    );
+
     let (ui, ui_fulldeps) = (path.join("ui"), path.join("ui-fulldeps"));
     let paths = [ui.as_path(), ui_fulldeps.as_path()];
     crate::walk::walk_no_read(&paths, |_, _| false, &mut |entry| {
@@ -100,6 +108,11 @@ pub fn check(path: &Path, bad: &mut bool) {
             {
                 tidy_error!(bad, "file {} has unexpected extension {}", file_path.display(), ext);
             }
+
+            // NB: We do not use file_stem() as some file names have multiple `.`s and we
+            // must strip all of them.
+            let testname =
+                file_path.file_name().unwrap().to_str().unwrap().split_once('.').unwrap().0;
             if ext == "stderr" || ext == "stdout" {
                 // Test output filenames have one of the formats:
                 // ```
@@ -111,12 +124,10 @@ pub fn check(path: &Path, bad: &mut bool) {
                 //
                 // For now, just make sure that there is a corresponding
                 // `$testname.rs` file.
-                //
-                // NB: We do not use file_stem() as some file names have multiple `.`s and we
-                // must strip all of them.
-                let testname =
-                    file_path.file_name().unwrap().to_str().unwrap().split_once('.').unwrap().0;
-                if !file_path.with_file_name(testname).with_extension("rs").exists() {
+
+                if !file_path.with_file_name(testname).with_extension("rs").exists()
+                    && !testname.contains("ignore-tidy")
+                {
                     tidy_error!(bad, "Stray file with UI testing output: {:?}", file_path);
                 }
 
@@ -126,6 +137,38 @@ pub fn check(path: &Path, bad: &mut bool) {
                     }
                 }
             }
+
+            if ext == "rs" {
+                lazy_static! {
+                    static ref ISSUE_NAME_REGEX: Regex =
+                        Regex::new(r"^issues?[-_]?\d{3,}").unwrap();
+                }
+
+                if ISSUE_NAME_REGEX.is_match(testname) {
+                    // these paths are always relative to the passed `path` and always UTF8
+                    let stripped_path = file_path.strip_prefix(path).unwrap().to_str().unwrap();
+                    if !allowed_issue_filenames.remove(stripped_path) {
+                        tidy_error!(
+                            bad,
+                            "UI test `{}` should use a name that describes the test and link the issue in a comment instead.",
+                            file_path.display(),
+                        );
+                    }
+                }
+            }
         }
     });
+
+    // if an excluded file is renamed, it must be removed from this list
+    if allowed_issue_filenames.len() > 0 {
+        for file_name in allowed_issue_filenames {
+            let mut p = PathBuf::from(path);
+            p.push(file_name);
+            tidy_error!(
+                bad,
+                "file `{}` no longer exists and should be removed from the exclusions in `src/tools/tidy/src/issues.txt`",
+                p.display()
+            );
+        }
+    }
 }
author	The Miri Conjob Bot <miri@cron.bot>	2023-07-26 06:32:12 +0000
committer	The Miri Conjob Bot <miri@cron.bot>	2023-07-26 06:32:12 +0000
commit	eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5 (patch)
tree	6b2403d4192e4adc6e70a4990d7f2c866c0af884 /src
parent	c5b26cd3ea0d7b012f1a10395e0b2e01c06d0335 (diff)
parent	7d773c3304731716cc54db3531ba54067ca55a4a (diff)
download	rust-eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5.tar.gz rust-eb3ccfd8410eb3a46ab7babe7ac63d4db5511ce5.zip