Merge ref '68ffae46b581' from rust-lang/rust

Pull recent changes from https://github.com/rust-lang/rust via Josh.

Upstream ref: rust-lang/rust@68ffae4
Filtered ref: rust-lang/compiler-builtins@7602939
Upstream diff: rust-lang/rust@d0442e2...68ffae4

This merge was created using https://github.com/rust-lang/josh-sync.

Author: The rustc-josh-sync Cronjob Bot

examples/rustc-interface-example.rs

@@ -50,7 +50,7 @@ fn main() {
         make_codegen_backend: None,
         expanded_args: Vec::new(),
         ice_file: None,
-        hash_untracked_state: None,
+        track_state: None,
         using_internal_features: &rustc_driver::USING_INTERNAL_FEATURES,
     };
     rustc_interface::run_compiler(config, |compiler| {
@@ -72,4 +72,4 @@ fn main() {
             }
         });
     });
-}
+}

examples/rustc-interface-getting-diagnostics.rs

@@ -78,7 +78,7 @@ fn main() {
         make_codegen_backend: None,
         expanded_args: Vec::new(),
         ice_file: None,
-        hash_untracked_state: None,
+        track_state: None,
         using_internal_features: &rustc_driver::USING_INTERNAL_FEATURES,
     };
     rustc_interface::run_compiler(config, |compiler| {
@@ -97,4 +97,4 @@ fn main() {
     buffer.lock().unwrap().iter().for_each(|diagnostic| {
         println!("{diagnostic:#?}");
     });
-}
+}

rust-version

@@ -1 +1 @@
-30d0309fa821f7a0984a9629e0d227ca3c0d2eda
+cf1817bc6ecd2d14ca492247c804bad31948dd56

src/about-this-guide.md

@@ -98,7 +98,7 @@ You might also find the following sites useful:
 [gsearchdocs]: https://www.google.com/search?q=site:doc.rust-lang.org+your+query+here
 [stddocs]: https://doc.rust-lang.org/std
 [rif]: http://internals.rust-lang.org
-[rr]: https://doc.rust-lang.org/book/
+[rr]: https://doc.rust-lang.org/reference/
 [rustforge]: https://forge.rust-lang.org/
 [tlgba]: https://tomlee.co/2014/04/a-more-detailed-tour-of-the-rust-compiler/
 [ro]: https://www.rustaceans.org/

src/building/suggested.md

@@ -144,77 +144,82 @@ If running `./x check` on save is inconvenient, in VS Code you can use a [Build
 
 ### Neovim
 
-For Neovim users, there are a few options.
-The easiest way is by using [neoconf.nvim](https://github.com/folke/neoconf.nvim/),
-which allows for project-local configuration files with the native LSP.
-The steps for how to use it are below.
-Note that they require rust-analyzer to already be configured with Neovim.
-Steps for this can be [found here](https://rust-analyzer.github.io/manual.html#nvim-lsp).
+For Neovim users, there are a few options:
+
+1. The easiest way is using [neoconf.nvim][neoconf.nvim] but it uses the
+   deprecated `require('lspconfig')` API which displays a warning on neovim 0.11+.
+2. Using `coc.nvim` is another option but it requires node.js to be installed.
+3. Using a custom script to load rust-analyzer settings.
+
+#### neoconf.nvim
+
+[neoconf.nvim][neoconf.nvim] allows for project-local configuration
+files with the native LSP. The steps for how to use it are below. Note that they require
+rust-analyzer to already be configured with Neovim. Steps for this can be
+[found here][r-a nvim lsp].
 
 1. First install the plugin.
    This can be done by following the steps in the README.
 2. Run `./x setup editor`, and select `vscode` to create a `.vscode/settings.json` file.
    `neoconf` is able to read and update
    rust-analyzer settings automatically when the project is opened when this file is detected.
 
+#### coc.nvim
+
 If you're using `coc.nvim`, you can run `./x setup editor` and select `vim` to
 create a `.vim/coc-settings.json`.
 The settings can be edited with `:CocLocalConfig`.
 The recommended settings live at [`src/etc/rust_analyzer_settings.json`].
 
-Another way is without a plugin, and creating your own logic in your configuration.
-The following code will work for any checkout of rust-lang/rust (newer than February 2025):
+#### Custom LSP settings
+
+If you're running neovim 0.11+, you can configure rust-analyzer with just
+[nvim-lspconfig](https://github.com/neovim/nvim-lspconfig) and a custom script.
+
+1. Make sure [rust-analyzer LSP][r-a nvim lsp] is set up
+2. Create `$HOME/.config/nvim/after/plugged/rust_analyzer.lua` with the following content:
 
 ```lua
-local function expand_config_variables(option)
-    local var_placeholders = {
-        ['${workspaceFolder}'] = function(_)
-            return vim.lsp.buf.list_workspace_folders()[1]
-        end,
-    }
-
-    if type(option) == "table" then
-        local mt = getmetatable(option)
-        local result = {}
-        for k, v in pairs(option) do
-            result[expand_config_variables(k)] = expand_config_variables(v)
+-- Capture the default functions from nvim-lspconfig/lsp/rust_analyzer.lua before overriding it.
+-- This file is in after/plugin to guarantee nvim-lspconfig has been initialised already.
+local default_root_dir = vim.lsp.config["rust_analyzer"].root_dir
+local default_before_init = vim.lsp.config["rust_analyzer"].before_init
+
+vim.lsp.config("rust_analyzer", {
+    cmd = { "rust-analyzer" },
+    filetypes = { "rust" },
+    -- To support rust-lang/rust, we need to detect when we're in the rust repo and use the git root
+    -- instead of cargo project root.
+    root_dir = function(bufnr, on_dir)
+        local git_root = vim.fs.root(bufnr, { ".git" })
+        if git_root then
+            if vim.uv.fs_stat(vim.fs.joinpath(git_root, "src/etc/rust_analyzer_zed.json")) then
+                on_dir(git_root)
+                return
+            end
         end
-        return setmetatable(result, mt)
-    end
-    if type(option) ~= "string" then
-        return option
-    end
-    local ret = option
-    for key, fn in pairs(var_placeholders) do
-        ret = ret:gsub(key, fn)
-    end
-    return ret
-end
-lspconfig.rust_analyzer.setup {
-    root_dir = function()
-        local default = lspconfig.rust_analyzer.config_def.default_config.root_dir()
-        -- the default root detection uses the cargo workspace root.
-        -- but for rust-lang/rust, the standard library is in its own workspace.
-        -- use the git root instead.
-        local compiler_config = vim.fs.joinpath(default, "../src/bootstrap/defaults/config.compiler.toml")
-        if vim.fs.basename(default) == "library" and vim.uv.fs_stat(compiler_config) then
-            return vim.fs.dirname(default)
-        end
-        return default
+        -- For anything that doesn't match rust-lang/rust, fallback to default root_dir
+        default_root_dir(bufnr, on_dir)
     end,
-    on_init = function(client)
-        local path = client.workspace_folders[1].name
-        local config = vim.fs.joinpath(path, "src/etc/rust_analyzer_zed.json")
-        if vim.uv.fs_stat(config) then
-            -- load rust-lang/rust settings
-            local file = io.open(config)
-            local json = vim.json.decode(file:read("*a"))
-            client.config.settings["rust-analyzer"] = expand_config_variables(json.lsp["rust-analyzer"].initialization_options)
-            client.notify("workspace/didChangeConfiguration", { settings = client.config.settings })
+    before_init = function(init_params, config)
+        -- When inside rust-lang/rust, we need to use the special rust-analyzer settings.
+        local settings = vim.fs.joinpath(config.root_dir, "src/etc/rust_analyzer_zed.json")
+        if vim.uv.fs_stat(settings) then
+            local file = io.open(settings)
+            -- nvim 0.12+ supports comments otherwise you'll need content:gsub("//[^\n]*", "").
+            local json = vim.json.decode(file:read("*a"), { skip_comments = true })
+            file:close()
+            config.settings["rust-analyzer"] = vim.tbl_deep_extend(
+                "force", -- Overwrite with the special settings when there is a conflict.
+                config.settings["rust-analyzer"] or {},
+                json.lsp["rust-analyzer"].initialization_options
+            )
         end
-        return true
-    end
-}
+        default_before_init(init_params, config)
+    end,
+})
+
+vim.lsp.enable("rust_analyzer")
 ```
 
 If you would like to use the build task that is described above, you may either
@@ -223,6 +228,9 @@ make your own command in your config, or you can install a plugin such as
 files](https://github.com/stevearc/overseer.nvim/blob/master/doc/guides.md#vs-code-tasks),
 and follow the same instructions as above.
 
+[neoconf.nvim]: https://github.com/folke/neoconf.nvim/
+[r-a nvim lsp]: https://rust-analyzer.github.io/book/other_editors.html#nvim-lsp
+
 ### Emacs
 
 Emacs provides support for rust-analyzer with project-local configuration

src/coherence.md

@@ -8,13 +8,14 @@ Coherence checking is what detects both of trait impls and inherent impls overla
 Overlapping trait impls always produce an error,
 while overlapping inherent impls result in an error only if they have methods with the same name.
 
-Checking for overlaps is split in two parts. First there's the [overlap check(s)](#overlap-checks), 
+Checking for overlaps is split in two parts.
+First there's the [overlap check(s)](#overlap-checks),
 which finds overlaps between traits and inherent implementations that the compiler currently knows about.
 
 However, Coherence also results in an error if any other impls **could** exist,
-even if they are currently unknown. 
+even if they are currently unknown.
 This affects impls which may get added to upstream crates in a backwards compatible way,
-and impls from downstream crates. 
+and impls from downstream crates.
 This is called the Orphan check.
 
 ## Overlap checks
@@ -25,7 +26,7 @@ Overlap checks always consider pairs of implementations, comparing them to each
 
 Overlap checking for inherent impl blocks is done through `fn check_item` (in coherence/inherent_impls_overlap.rs),
 where you can very clearly see that (at least for small `n`), the check really performs `n^2`
-comparisons between impls. 
+comparisons between impls.
 
 In the case of traits, this check is currently done as part of building the [specialization graph](traits/specialization.md),
 to handle specializing impls overlapping with their parent, but this may change in the future.
@@ -37,7 +38,7 @@ Overlapping is sometimes partially allowed:
 1. for marker traits
 2. under [specialization](traits/specialization.md)
 
-but normally isn't. 
+It normally isn't.
 
 The overlap check has various modes (see [`OverlapMode`]).
 Importantly, there's the explicit negative impl check, and the implicit negative impl check.
@@ -47,9 +48,9 @@ Both try to prove that an overlap is definitely impossible.
 
 ### The explicit negative impl check
 
-This check is done in [`impl_intersection_has_negative_obligation`]. 
+This check is done in [`impl_intersection_has_negative_obligation`].
 
-This check tries to find a negative trait implementation. 
+This check tries to find a negative trait implementation.
 For example:
 
 ```rust
@@ -64,7 +65,7 @@ In this example, we'd get:
 `MyCustomErrorType: From<&str>` and `MyCustomErrorType: From<?E>`, giving `?E = &str`.
 
 And thus, these two implementations would overlap.
-However, libstd provides `&str: !Error`, and therefore guarantees that there 
+However, libstd provides `&str: !Error`, and therefore guarantees that there
 will never be a positive implementation of `&str: Error`, and thus there is no overlap.
 
 Note that for this kind of negative impl check, we must have explicit negative implementations provided.
@@ -77,18 +78,17 @@ This is not currently stable.
 This check is done in [`impl_intersection_has_impossible_obligation`],
 and does not rely on negative trait implementations and is stable.
 
-Let's say there's a 
+Let's say there's a
 ```rust
 impl From<MyLocalType> for Box<dyn Error> {}  // in your own crate
 impl<E> From<E> for Box<dyn Error> where E: Error {} // in std
 ```
 
-This would give: `Box<dyn Error>: From<MyLocalType>`, and `Box<dyn Error>: From<?E>`,  
+This would give: `Box<dyn Error>: From<MyLocalType>`, and `Box<dyn Error>: From<?E>`,
 giving `?E = MyLocalType`.
 
 In your crate there's no `MyLocalType: Error`, downstream crates cannot implement `Error` (a remote trait) for `MyLocalType` (a remote type).
 Therefore, these two impls do not overlap.
 Importantly, this works even if there isn't a `impl !Error for MyLocalType`.
 
 [`impl_intersection_has_impossible_obligation`]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_trait_selection/traits/coherence/fn.impl_intersection_has_impossible_obligation.html
-

src/compiler-debugging.md

@@ -273,18 +273,18 @@ Here are some notable ones:
 
 | Attribute | Description |
 |----------------|-------------|
-| `rustc_def_path` | Dumps the [`def_path_str`] of an item. |
 | `rustc_dump_def_parents` | Dumps the chain of `DefId` parents of certain definitions. |
+| `rustc_dump_def_path` | Dumps the [`def_path_str`] of an item. |
+| `rustc_dump_hidden_type_of_opaques` | Dumps the [hidden type of each opaque types][opaq] in the crate. |
 | `rustc_dump_inferred_outlives` | Dumps implied bounds of an item. More precisely, the [`inferred_outlives_of`] an item. |
 | `rustc_dump_item_bounds` | Dumps the [`item_bounds`] of an item. |
+| `rustc_dump_layout` | [See this section](#debugging-type-layouts). |
 | `rustc_dump_object_lifetime_defaults` | Dumps the [object lifetime defaults] of an item. |
 | `rustc_dump_predicates` | Dumps the [`predicates_of`] an item. |
+| `rustc_dump_symbol_name` | Dumps the mangled & demangled [`symbol_name`] of an item. |
 | `rustc_dump_variances` | Dumps the [variances] of an item. |
 | `rustc_dump_vtable` | Dumps the vtable layout of an impl, or a type alias of a dyn type. |
-| `rustc_hidden_type_of_opaques` | Dumps the [hidden type of each opaque types][opaq] in the crate. |
-| `rustc_layout` | [See this section](#debugging-type-layouts). |
 | `rustc_regions` | Dumps NLL closure region requirements. |
-| `rustc_symbol_name` | Dumps the mangled & demangled [`symbol_name`] of an item. |
 
 Right below you can find elaborate explainers on a selected few.
 
@@ -316,54 +316,55 @@ $ firefox maybe_init_suffix.pdf # Or your favorite pdf viewer
 
 ### Debugging type layouts
 
-The internal attribute `#[rustc_layout]` can be used to dump the [`Layout`] of
-the type it is attached to.
+The internal attribute `#[rustc_dump_layout(...)]` can be used to dump the
+[`Layout`] of the type it is attached to.
 For example:
 
 ```rust
 #![feature(rustc_attrs)]
 
-#[rustc_layout(debug)]
+#[rustc_dump_layout(debug)]
 type T<'a> = &'a u32;
 ```
 
 Will emit the following:
 
 ```text
-error: layout_of(&'a u32) = Layout {
-    fields: Primitive,
-    variants: Single {
-        index: 0,
-    },
-    abi: Scalar(
-        Scalar {
-            value: Pointer,
-            valid_range: 1..=18446744073709551615,
-        },
-    ),
-    largest_niche: Some(
-        Niche {
-            offset: Size {
-                raw: 0,
-            },
-            scalar: Scalar {
-                value: Pointer,
-                valid_range: 1..=18446744073709551615,
-            },
-        },
-    ),
-    align: AbiAndPrefAlign {
-        abi: Align {
-            pow2: 3,
-        },
-        pref: Align {
-            pow2: 3,
-        },
-    },
-    size: Size {
-        raw: 8,
-    },
-}
+error: layout_of(&u32) = Layout {
+           size: Size(8 bytes),
+           align: AbiAlign {
+               abi: Align(8 bytes),
+           },
+           backend_repr: Scalar(
+               Initialized {
+                   value: Pointer(
+                       AddressSpace(
+                           0,
+                       ),
+                   ),
+                   valid_range: 1..=18446744073709551615,
+               },
+           ),
+           fields: Primitive,
+           largest_niche: Some(
+               Niche {
+                   offset: Size(0 bytes),
+                   value: Pointer(
+                       AddressSpace(
+                           0,
+                       ),
+                   ),
+                   valid_range: 1..=18446744073709551615,
+               },
+           ),
+           uninhabited: false,
+           variants: Single {
+               index: 0,
+           },
+           max_repr_align: None,
+           unadjusted_abi_align: Align(8 bytes),
+           randomization_seed: 281492156579847,
+       }
  --> src/lib.rs:4:1
   |
 4 | type T<'a> = &'a u32;