Auto merge of #133160 - jhpratt:rollup-wzj9q15, r=jhpratt

Rollup of 4 pull requests

Successful merges:

 - #132934 (Overhaul the `-l` option parser (for linking to native libs))
 - #133142 (rename rustc_const_stable_intrinsic -> rustc_intrinsic_const_stable_indirect)
 - #133145 (Document alternatives to `static mut`)
 - #133158 (Subtree update of `rust-analyzer`)

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

Author: bors

compiler/rustc_const_eval/messages.ftl

@@ -403,7 +403,7 @@ const_eval_uninhabited_enum_variant_written =
 const_eval_unmarked_const_fn_exposed = `{$def_path}` cannot be (indirectly) exposed to stable
     .help = either mark the callee as `#[rustc_const_stable_indirect]`, or the caller as `#[rustc_const_unstable]`
 const_eval_unmarked_intrinsic_exposed = intrinsic `{$def_path}` cannot be (indirectly) exposed to stable
-    .help = mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_const_stable_intrinsic]` (but this requires team approval)
+    .help = mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_intrinsic_const_stable_indirect]` (but this requires team approval)
 
 const_eval_unreachable = entering unreachable code
 const_eval_unreachable_unwind =

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -760,7 +760,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }) => {
                             // All good. Note that a `#[rustc_const_stable]` intrinsic (meaning it
                             // can be *directly* invoked from stable const code) does not always
-                            // have the `#[rustc_const_stable_intrinsic]` attribute (which controls
+                            // have the `#[rustc_intrinsic_const_stable_indirect]` attribute (which controls
                             // exposing an intrinsic indirectly); we accept this call anyway.
                         }
                     }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -838,7 +838,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(Word), WarnFollowing, EncodeCrossCrate::No, IMPL_DETAIL,
     ),
     rustc_attr!(
-        rustc_const_stable_intrinsic, Normal,
+        rustc_intrinsic_const_stable_indirect, Normal,
         template!(Word), WarnFollowing, EncodeCrossCrate::No, IMPL_DETAIL,
     ),
     gated!(

compiler/rustc_middle/src/ty/util.rs

@@ -1793,7 +1793,7 @@ pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Intrinsi
         Some(ty::IntrinsicDef {
             name: tcx.item_name(def_id.into()),
             must_be_overridden: tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden),
-            const_stable: tcx.has_attr(def_id, sym::rustc_const_stable_intrinsic),
+            const_stable: tcx.has_attr(def_id, sym::rustc_intrinsic_const_stable_indirect),
         })
     } else {
         None

compiler/rustc_session/src/config.rs

@@ -30,17 +30,18 @@ use rustc_target::spec::{
 };
 use tracing::debug;
 
+pub use crate::config::cfg::{Cfg, CheckCfg, ExpectedValues};
+use crate::config::native_libs::parse_native_libs;
 use crate::errors::FileWriteFail;
 pub use crate::options::*;
 use crate::search_paths::SearchPath;
-use crate::utils::{CanonicalizedPath, NativeLib, NativeLibKind};
+use crate::utils::CanonicalizedPath;
 use crate::{EarlyDiagCtxt, HashStableContext, Session, filesearch, lint};
 
 mod cfg;
+mod native_libs;
 pub mod sigpipe;
 
-pub use cfg::{Cfg, CheckCfg, ExpectedValues};
-
 /// The different settings that the `-C strip` flag can have.
 #[derive(Clone, Copy, PartialEq, Hash, Debug)]
 pub enum Strip {
@@ -2134,143 +2135,6 @@ fn parse_assert_incr_state(
     }
 }
 
-fn parse_native_lib_kind(
-    early_dcx: &EarlyDiagCtxt,
-    matches: &getopts::Matches,
-    kind: &str,
-) -> (NativeLibKind, Option<bool>) {
-    let (kind, modifiers) = match kind.split_once(':') {
-        None => (kind, None),
-        Some((kind, modifiers)) => (kind, Some(modifiers)),
-    };
-
-    let kind = match kind {
-        "static" => NativeLibKind::Static { bundle: None, whole_archive: None },
-        "dylib" => NativeLibKind::Dylib { as_needed: None },
-        "framework" => NativeLibKind::Framework { as_needed: None },
-        "link-arg" => {
-            if !nightly_options::is_unstable_enabled(matches) {
-                let why = if nightly_options::match_is_nightly_build(matches) {
-                    " and only accepted on the nightly compiler"
-                } else {
-                    ", the `-Z unstable-options` flag must also be passed to use it"
-                };
-                early_dcx.early_fatal(format!("library kind `link-arg` is unstable{why}"))
-            }
-            NativeLibKind::LinkArg
-        }
-        _ => early_dcx.early_fatal(format!(
-            "unknown library kind `{kind}`, expected one of: static, dylib, framework, link-arg"
-        )),
-    };
-    match modifiers {
-        None => (kind, None),
-        Some(modifiers) => parse_native_lib_modifiers(early_dcx, kind, modifiers, matches),
-    }
-}
-
-fn parse_native_lib_modifiers(
-    early_dcx: &EarlyDiagCtxt,
-    mut kind: NativeLibKind,
-    modifiers: &str,
-    matches: &getopts::Matches,
-) -> (NativeLibKind, Option<bool>) {
-    let mut verbatim = None;
-    for modifier in modifiers.split(',') {
-        let (modifier, value) = match modifier.strip_prefix(['+', '-']) {
-            Some(m) => (m, modifier.starts_with('+')),
-            None => early_dcx.early_fatal(
-                "invalid linking modifier syntax, expected '+' or '-' prefix \
-                 before one of: bundle, verbatim, whole-archive, as-needed",
-            ),
-        };
-
-        let report_unstable_modifier = || {
-            if !nightly_options::is_unstable_enabled(matches) {
-                let why = if nightly_options::match_is_nightly_build(matches) {
-                    " and only accepted on the nightly compiler"
-                } else {
-                    ", the `-Z unstable-options` flag must also be passed to use it"
-                };
-                early_dcx.early_fatal(format!("linking modifier `{modifier}` is unstable{why}"))
-            }
-        };
-        let assign_modifier = |dst: &mut Option<bool>| {
-            if dst.is_some() {
-                let msg = format!("multiple `{modifier}` modifiers in a single `-l` option");
-                early_dcx.early_fatal(msg)
-            } else {
-                *dst = Some(value);
-            }
-        };
-        match (modifier, &mut kind) {
-            ("bundle", NativeLibKind::Static { bundle, .. }) => assign_modifier(bundle),
-            ("bundle", _) => early_dcx.early_fatal(
-                "linking modifier `bundle` is only compatible with `static` linking kind",
-            ),
-
-            ("verbatim", _) => assign_modifier(&mut verbatim),
-
-            ("whole-archive", NativeLibKind::Static { whole_archive, .. }) => {
-                assign_modifier(whole_archive)
-            }
-            ("whole-archive", _) => early_dcx.early_fatal(
-                "linking modifier `whole-archive` is only compatible with `static` linking kind",
-            ),
-
-            ("as-needed", NativeLibKind::Dylib { as_needed })
-            | ("as-needed", NativeLibKind::Framework { as_needed }) => {
-                report_unstable_modifier();
-                assign_modifier(as_needed)
-            }
-            ("as-needed", _) => early_dcx.early_fatal(
-                "linking modifier `as-needed` is only compatible with \
-                 `dylib` and `framework` linking kinds",
-            ),
-
-            // Note: this error also excludes the case with empty modifier
-            // string, like `modifiers = ""`.
-            _ => early_dcx.early_fatal(format!(
-                "unknown linking modifier `{modifier}`, expected one \
-                     of: bundle, verbatim, whole-archive, as-needed"
-            )),
-        }
-    }
-
-    (kind, verbatim)
-}
-
-fn parse_libs(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Vec<NativeLib> {
-    matches
-        .opt_strs("l")
-        .into_iter()
-        .map(|s| {
-            // Parse string of the form "[KIND[:MODIFIERS]=]lib[:new_name]",
-            // where KIND is one of "dylib", "framework", "static", "link-arg" and
-            // where MODIFIERS are a comma separated list of supported modifiers
-            // (bundle, verbatim, whole-archive, as-needed). Each modifier is prefixed
-            // with either + or - to indicate whether it is enabled or disabled.
-            // The last value specified for a given modifier wins.
-            let (name, kind, verbatim) = match s.split_once('=') {
-                None => (s, NativeLibKind::Unspecified, None),
-                Some((kind, name)) => {
-                    let (kind, verbatim) = parse_native_lib_kind(early_dcx, matches, kind);
-                    (name.to_string(), kind, verbatim)
-                }
-            };
-
-            let (name, new_name) = match name.split_once(':') {
-                None => (name, None),
-                Some((name, new_name)) => (name.to_string(), Some(new_name.to_owned())),
-            };
-            if name.is_empty() {
-                early_dcx.early_fatal("library name must not be empty");
-            }
-            NativeLib { name, new_name, kind, verbatim }
-        })
-        .collect()
-}
-
 pub fn parse_externs(
     early_dcx: &EarlyDiagCtxt,
     matches: &getopts::Matches,
@@ -2644,7 +2508,10 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     let debuginfo = select_debuginfo(matches, &cg);
     let debuginfo_compression = unstable_opts.debuginfo_compression;
 
-    let libs = parse_libs(early_dcx, matches);
+    let crate_name = matches.opt_str("crate-name");
+    let unstable_features = UnstableFeatures::from_environment(crate_name.as_deref());
+    // Parse any `-l` flags, which link to native libraries.
+    let libs = parse_native_libs(early_dcx, &unstable_opts, unstable_features, matches);
 
     let test = matches.opt_present("test");
 
@@ -2659,8 +2526,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
 
     let externs = parse_externs(early_dcx, matches, &unstable_opts);
 
-    let crate_name = matches.opt_str("crate-name");
-
     let remap_path_prefix = parse_remap_path_prefix(early_dcx, matches, &unstable_opts);
 
     let pretty = parse_pretty(early_dcx, &unstable_opts);
@@ -2734,7 +2599,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         error_format,
         diagnostic_width,
         externs,
-        unstable_features: UnstableFeatures::from_environment(crate_name.as_deref()),
+        unstable_features,
         crate_name,
         libs,
         debug_assertions,

compiler/rustc_session/src/config/native_libs.rs

@@ -0,0 +1,192 @@
+//! Parser for the `-l` command-line option, which links the generated crate to
+//! a native library.
+//!
+//! (There is also a similar but separate syntax for `#[link]` attributes,
+//! which have their own parser in `rustc_metadata`.)
+
+use rustc_feature::UnstableFeatures;
+
+use crate::EarlyDiagCtxt;
+use crate::config::UnstableOptions;
+use crate::utils::{NativeLib, NativeLibKind};
+
+#[cfg(test)]
+mod tests;
+
+/// Parses all `-l` options.
+pub(crate) fn parse_native_libs(
+    early_dcx: &EarlyDiagCtxt,
+    unstable_opts: &UnstableOptions,
+    unstable_features: UnstableFeatures,
+    matches: &getopts::Matches,
+) -> Vec<NativeLib> {
+    let cx = ParseNativeLibCx {
+        early_dcx,
+        unstable_options_enabled: unstable_opts.unstable_options,
+        is_nightly: unstable_features.is_nightly_build(),
+    };
+    matches.opt_strs("l").into_iter().map(|value| parse_native_lib(&cx, &value)).collect()
+}
+
+struct ParseNativeLibCx<'a> {
+    early_dcx: &'a EarlyDiagCtxt,
+    unstable_options_enabled: bool,
+    is_nightly: bool,
+}
+
+impl ParseNativeLibCx<'_> {
+    /// If unstable values are not permitted, exits with a fatal error made by
+    /// combining the given strings.
+    fn on_unstable_value(&self, message: &str, if_nightly: &str, if_stable: &str) {
+        if self.unstable_options_enabled {
+            return;
+        }
+
+        let suffix = if self.is_nightly { if_nightly } else { if_stable };
+        self.early_dcx.early_fatal(format!("{message}{suffix}"));
+    }
+}
+
+/// Parses the value of a single `-l` option.
+fn parse_native_lib(cx: &ParseNativeLibCx<'_>, value: &str) -> NativeLib {
+    let NativeLibParts { kind, modifiers, name, new_name } = split_native_lib_value(value);
+
+    let kind = kind.map_or(NativeLibKind::Unspecified, |kind| match kind {
+        "static" => NativeLibKind::Static { bundle: None, whole_archive: None },
+        "dylib" => NativeLibKind::Dylib { as_needed: None },
+        "framework" => NativeLibKind::Framework { as_needed: None },
+        "link-arg" => {
+            cx.on_unstable_value(
+                "library kind `link-arg` is unstable",
+                ", the `-Z unstable-options` flag must also be passed to use it",
+                " and only accepted on the nightly compiler",
+            );
+            NativeLibKind::LinkArg
+        }
+        _ => cx.early_dcx.early_fatal(format!(
+            "unknown library kind `{kind}`, expected one of: static, dylib, framework, link-arg"
+        )),
+    });
+
+    // Provisionally create the result, so that modifiers can modify it.
+    let mut native_lib = NativeLib {
+        name: name.to_owned(),
+        new_name: new_name.map(str::to_owned),
+        kind,
+        verbatim: None,
+    };
+
+    if let Some(modifiers) = modifiers {
+        // If multiple modifiers are present, they are separated by commas.
+        for modifier in modifiers.split(',') {
+            parse_and_apply_modifier(cx, modifier, &mut native_lib);
+        }
+    }
+
+    if native_lib.name.is_empty() {
+        cx.early_dcx.early_fatal("library name must not be empty");
+    }
+
+    native_lib
+}
+
+/// Parses one of the comma-separated modifiers (prefixed by `+` or `-`), and
+/// modifies `native_lib` appropriately.
+///
+/// Exits with a fatal error if a malformed/unknown/inappropriate modifier is
+/// found.
+fn parse_and_apply_modifier(cx: &ParseNativeLibCx<'_>, modifier: &str, native_lib: &mut NativeLib) {
+    let early_dcx = cx.early_dcx;
+
+    // Split off the leading `+` or `-` into a boolean value.
+    let (modifier, value) = match modifier.split_at_checked(1) {
+        Some(("+", m)) => (m, true),
+        Some(("-", m)) => (m, false),
+        _ => cx.early_dcx.early_fatal(
+            "invalid linking modifier syntax, expected '+' or '-' prefix \
+             before one of: bundle, verbatim, whole-archive, as-needed",
+        ),
+    };
+
+    // Assigns the value (from `+` or `-`) to an empty `Option<bool>`, or emits
+    // a fatal error if the option has already been set.
+    let assign_modifier = |opt_bool: &mut Option<bool>| {
+        if opt_bool.is_some() {
+            let msg = format!("multiple `{modifier}` modifiers in a single `-l` option");
+            early_dcx.early_fatal(msg)
+        }
+        *opt_bool = Some(value);
+    };
+
+    // Check that the modifier is applicable to the native lib kind, and apply it.
+    match (modifier, &mut native_lib.kind) {
+        ("bundle", NativeLibKind::Static { bundle, .. }) => assign_modifier(bundle),
+        ("bundle", _) => early_dcx
+            .early_fatal("linking modifier `bundle` is only compatible with `static` linking kind"),
+
+        ("verbatim", _) => assign_modifier(&mut native_lib.verbatim),
+
+        ("whole-archive", NativeLibKind::Static { whole_archive, .. }) => {
+            assign_modifier(whole_archive)
+        }
+        ("whole-archive", _) => early_dcx.early_fatal(
+            "linking modifier `whole-archive` is only compatible with `static` linking kind",
+        ),
+
+        ("as-needed", NativeLibKind::Dylib { as_needed })
+        | ("as-needed", NativeLibKind::Framework { as_needed }) => {
+            cx.on_unstable_value(
+                "linking modifier `as-needed` is unstable",
+                ", the `-Z unstable-options` flag must also be passed to use it",
+                " and only accepted on the nightly compiler",
+            );
+            assign_modifier(as_needed)
+        }
+        ("as-needed", _) => early_dcx.early_fatal(
+            "linking modifier `as-needed` is only compatible with \
+             `dylib` and `framework` linking kinds",
+        ),
+
+        _ => early_dcx.early_fatal(format!(
+            "unknown linking modifier `{modifier}`, expected one \
+             of: bundle, verbatim, whole-archive, as-needed"
+        )),
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct NativeLibParts<'a> {
+    kind: Option<&'a str>,
+    modifiers: Option<&'a str>,
+    name: &'a str,
+    new_name: Option<&'a str>,
+}
+
+/// Splits a string of the form `[KIND[:MODIFIERS]=]NAME[:NEW_NAME]` into those
+/// individual parts. This cannot fail, but the resulting strings require
+/// further validation.
+fn split_native_lib_value(value: &str) -> NativeLibParts<'_> {
+    // Split the initial value into `[KIND=]NAME`.
+    let name = value;
+    let (kind, name) = match name.split_once('=') {
+        Some((prefix, name)) => (Some(prefix), name),
+        None => (None, name),
+    };
+
+    // Split the kind part, if present, into `KIND[:MODIFIERS]`.
+    let (kind, modifiers) = match kind {
+        Some(kind) => match kind.split_once(':') {
+            Some((kind, modifiers)) => (Some(kind), Some(modifiers)),
+            None => (Some(kind), None),
+        },
+        None => (None, None),
+    };
+
+    // Split the name part into `NAME[:NEW_NAME]`.
+    let (name, new_name) = match name.split_once(':') {
+        Some((name, new_name)) => (name, Some(new_name)),
+        None => (name, None),
+    };
+
+    NativeLibParts { kind, modifiers, name, new_name }
+}

compiler/rustc_session/src/config/native_libs/tests.rs

@@ -0,0 +1,50 @@
+use crate::config::native_libs::{NativeLibParts, split_native_lib_value};
+
+#[test]
+fn split() {
+    // This is a unit test for some implementation details, so consider deleting
+    // it if it gets in the way.
+    use NativeLibParts as P;
+
+    let examples = &[
+        ("", P { kind: None, modifiers: None, name: "", new_name: None }),
+        ("foo", P { kind: None, modifiers: None, name: "foo", new_name: None }),
+        ("foo:", P { kind: None, modifiers: None, name: "foo", new_name: Some("") }),
+        ("foo:bar", P { kind: None, modifiers: None, name: "foo", new_name: Some("bar") }),
+        (":bar", P { kind: None, modifiers: None, name: "", new_name: Some("bar") }),
+        ("kind=foo", P { kind: Some("kind"), modifiers: None, name: "foo", new_name: None }),
+        (":mods=foo", P { kind: Some(""), modifiers: Some("mods"), name: "foo", new_name: None }),
+        (":mods=:bar", P {
+            kind: Some(""),
+            modifiers: Some("mods"),
+            name: "",
+            new_name: Some("bar"),
+        }),
+        ("kind=foo:bar", P {
+            kind: Some("kind"),
+            modifiers: None,
+            name: "foo",
+            new_name: Some("bar"),
+        }),
+        ("kind:mods=foo", P {
+            kind: Some("kind"),
+            modifiers: Some("mods"),
+            name: "foo",
+            new_name: None,
+        }),
+        ("kind:mods=foo:bar", P {
+            kind: Some("kind"),
+            modifiers: Some("mods"),
+            name: "foo",
+            new_name: Some("bar"),
+        }),
+        ("::==::", P { kind: Some(""), modifiers: Some(":"), name: "=", new_name: Some(":") }),
+        ("==::==", P { kind: Some(""), modifiers: None, name: "=", new_name: Some(":==") }),
+    ];
+
+    for &(value, ref expected) in examples {
+        println!("{value:?}");
+        let actual = split_native_lib_value(value);
+        assert_eq!(&actual, expected);
+    }
+}

compiler/rustc_span/src/symbol.rs

@@ -1666,7 +1666,6 @@ symbols! {
         rustc_const_panic_str,
         rustc_const_stable,
         rustc_const_stable_indirect,
-        rustc_const_stable_intrinsic,
         rustc_const_unstable,
         rustc_conversion_suggestion,
         rustc_deallocator,
@@ -1696,6 +1695,7 @@ symbols! {
         rustc_inherit_overflow_checks,
         rustc_insignificant_dtor,
         rustc_intrinsic,
+        rustc_intrinsic_const_stable_indirect,
         rustc_intrinsic_must_be_overridden,
         rustc_layout,
         rustc_layout_scalar_valid_range_end,

library/core/src/intrinsics/mod.rs

@@ -1448,6 +1448,9 @@ mod self_upper_keyword {}
 /// in a multithreaded context. As such, all accesses to mutable `static`s
 /// require an [`unsafe`] block.
 ///
+/// When possible, it's often better to use a non-mutable `static` with an
+/// interior mutable type such as [`Mutex`], [`OnceLock`], or an [atomic].
+///
 /// Despite their unsafety, mutable `static`s are necessary in many contexts:
 /// they can be used to represent global state shared by the whole program or in
 /// [`extern`] blocks to bind to variables from C libraries.
@@ -1468,7 +1471,10 @@ mod self_upper_keyword {}
 /// [`extern`]: keyword.extern.html
 /// [`mut`]: keyword.mut.html
 /// [`unsafe`]: keyword.unsafe.html
+/// [`Mutex`]: sync::Mutex
+/// [`OnceLock`]: sync::OnceLock
 /// [`RefCell`]: cell::RefCell
+/// [atomic]: sync::atomic
 /// [Reference]: ../reference/items/static-items.html
 mod static_keyword {}
 

src/tools/rust-analyzer/Cargo.lock

@@ -1,7 +1,7 @@
 use either::Either;
 use ide_db::FxHashMap;
 use itertools::Itertools;
-use syntax::{ast, ted, AstNode, SmolStr, ToSmolStr};
+use syntax::{ast, syntax_editor::SyntaxEditor, AstNode, SmolStr, SyntaxElement, ToSmolStr};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -24,6 +24,11 @@ pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
     let record =
         path.syntax().parent().and_then(<Either<ast::RecordExpr, ast::RecordPat>>::cast)?;
 
+    let parent_node = match ctx.covering_element() {
+        SyntaxElement::Node(n) => n,
+        SyntaxElement::Token(t) => t.parent()?,
+    };
+
     let ranks = compute_fields_ranks(&path, ctx)?;
     let get_rank_of_field = |of: Option<SmolStr>| {
         *ranks.get(of.unwrap_or_default().trim_start_matches("r#")).unwrap_or(&usize::MAX)
@@ -65,23 +70,31 @@ pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         AssistId("reorder_fields", AssistKind::RefactorRewrite),
         "Reorder record fields",
         target,
-        |builder| match fields {
-            Either::Left((sorted, field_list)) => {
-                replace(builder.make_mut(field_list).fields(), sorted)
-            }
-            Either::Right((sorted, field_list)) => {
-                replace(builder.make_mut(field_list).fields(), sorted)
+        |builder| {
+            let mut editor = builder.make_editor(&parent_node);
+
+            match fields {
+                Either::Left((sorted, field_list)) => {
+                    replace(&mut editor, field_list.fields(), sorted)
+                }
+                Either::Right((sorted, field_list)) => {
+                    replace(&mut editor, field_list.fields(), sorted)
+                }
             }
+
+            builder.add_file_edits(ctx.file_id(), editor);
         },
     )
 }
 
 fn replace<T: AstNode + PartialEq>(
+    editor: &mut SyntaxEditor,
     fields: impl Iterator<Item = T>,
     sorted_fields: impl IntoIterator<Item = T>,
 ) {
     fields.zip(sorted_fields).for_each(|(field, sorted_field)| {
-        ted::replace(field.syntax(), sorted_field.syntax().clone_for_update())
+        // FIXME: remove `clone_for_update` when `SyntaxEditor` handles it for us
+        editor.replace(field.syntax(), sorted_field.syntax().clone_for_update())
     });
 }
 

src/tools/rust-analyzer/crates/ide-assists/src/handlers/reorder_fields.rs

@@ -511,12 +511,16 @@ pub(crate) fn handle_document_diagnostics(
         .into_iter()
         .filter_map(|d| {
             let file = d.range.file_id;
-            let diagnostic = convert_diagnostic(&line_index, d);
             if file == file_id {
+                let diagnostic = convert_diagnostic(&line_index, d);
                 return Some(diagnostic);
             }
             if supports_related {
-                related_documents.entry(file).or_insert_with(Vec::new).push(diagnostic);
+                let (diagnostics, line_index) = related_documents
+                    .entry(file)
+                    .or_insert_with(|| (Vec::new(), snap.file_line_index(file).ok()));
+                let diagnostic = convert_diagnostic(line_index.as_mut()?, d);
+                diagnostics.push(diagnostic);
             }
             None
         });
@@ -529,7 +533,7 @@ pub(crate) fn handle_document_diagnostics(
             related_documents: related_documents.is_empty().not().then(|| {
                 related_documents
                     .into_iter()
-                    .map(|(id, items)| {
+                    .map(|(id, (items, _))| {
                         (
                             to_proto::url(&snap, id),
                             lsp_types::DocumentDiagnosticReportKind::Full(

src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs

@@ -74,7 +74,7 @@ error: intrinsic `copy::copy` cannot be (indirectly) exposed to stable
 LL |     unsafe { copy(src, dst, count) }
    |              ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_const_stable_intrinsic]` (but this requires team approval)
+   = help: mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_intrinsic_const_stable_indirect]` (but this requires team approval)
 
 error: const function that might be (indirectly) exposed to stable cannot use `#[feature(local)]`
   --> $DIR/const-unstable-intrinsic.rs:61:9

tests/ui/consts/const-unstable-intrinsic.stderr

@@ -1,5 +1,5 @@
 error[E0658]: link kind `link-arg` is unstable
-  --> $DIR/feature-gate-link-arg-attribute.rs:1:15
+  --> $DIR/feature-gate-link-arg-attribute.rs:5:15
    |
 LL | #[link(kind = "link-arg", name = "foo")]
    |               ^^^^^^^^^^

tests/ui/feature-gates/feature-gate-link-arg-attribute.stderr renamed to tests/ui/feature-gates/feature-gate-link-arg-attribute.in_attr.stderr

@@ -0,0 +1,2 @@
+error: unknown linking modifier `link-arg`, expected one of: bundle, verbatim, whole-archive, as-needed
+

tests/ui/feature-gates/feature-gate-link-arg-attribute.in_flag.stderr

@@ -1,5 +1,9 @@
+//@ revisions: in_attr in_flag
+//@[in_flag] compile-flags: -l dylib:+link-arg=foo
+
+#[cfg(in_attr)]
 #[link(kind = "link-arg", name = "foo")]
-//~^ ERROR link kind `link-arg` is unstable
+//[in_attr]~^ ERROR link kind `link-arg` is unstable
 extern "C" {}
 
 fn main() {}

tests/ui/feature-gates/feature-gate-link-arg-attribute.rs

@@ -1,5 +1,5 @@
 error[E0658]: linking modifier `as-needed` is unstable
-  --> $DIR/feature-gate-native_link_modifiers_as_needed.rs:1:50
+  --> $DIR/feature-gate-native_link_modifiers_as_needed.rs:5:50
    |
 LL | #[link(name = "foo", kind = "dylib", modifiers = "+as-needed")]
    |                                                  ^^^^^^^^^^^^

tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.stderr renamed to tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.in_attr.stderr

@@ -0,0 +1,2 @@
+error: linking modifier `as-needed` is unstable, the `-Z unstable-options` flag must also be passed to use it
+

tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.in_flag.stderr

@@ -1,5 +1,9 @@
+//@ revisions: in_attr in_flag
+//@[in_flag] compile-flags: -l dylib:+as-needed=foo
+
+#[cfg(in_attr)]
 #[link(name = "foo", kind = "dylib", modifiers = "+as-needed")]
-//~^ ERROR: linking modifier `as-needed` is unstable
+//[in_attr]~^ ERROR: linking modifier `as-needed` is unstable
 extern "C" {}
 
 fn main() {}

tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.rs

@@ -0,0 +1,2 @@
+error: invalid linking modifier syntax, expected '+' or '-' prefix before one of: bundle, verbatim, whole-archive, as-needed
+

tests/ui/native-library-link-flags/modifiers-bad.blank.stderr

@@ -0,0 +1,2 @@
+error: invalid linking modifier syntax, expected '+' or '-' prefix before one of: bundle, verbatim, whole-archive, as-needed
+

tests/ui/native-library-link-flags/modifiers-bad.no-prefix.stderr

@@ -0,0 +1,2 @@
+error: unknown linking modifier ``, expected one of: bundle, verbatim, whole-archive, as-needed
+

tests/ui/native-library-link-flags/modifiers-bad.prefix-only.stderr

@@ -0,0 +1,11 @@
+//@ edition: 2021
+//@ revisions: blank no-prefix prefix-only unknown
+
+//@[blank] compile-flags: -l static:=foo
+//@[no-prefix] compile-flags: -l static:bundle=foo
+//@[prefix-only] compile-flags: -l static:+=foo
+//@[unknown] compile-flags: -l static:+ferris=foo
+
+// Tests various illegal values for the "modifier" part of an `-l` flag.
+
+fn main() {}

tests/ui/native-library-link-flags/modifiers-bad.rs

@@ -0,0 +1,2 @@
+error: unknown linking modifier `ferris`, expected one of: bundle, verbatim, whole-archive, as-needed
+