Rollup of 9 pull requests

compiler/rustc_hir_typeck/src/demand.rs

@@ -40,6 +40,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             || self.suggest_semicolon_in_repeat_expr(err, expr, expr_ty)
             || self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr)
             || self.suggest_option_to_bool(err, expr, expr_ty, expected)
+            || self.suggest_collect(err, expr, expected, expr_ty)
             || self.suggest_compatible_variants(err, expr, expected, expr_ty)
             || self.suggest_non_zero_new_unwrap(err, expr, expected, expr_ty)
             || self.suggest_calling_boxed_future_when_appropriate(err, expr, expected, expr_ty)

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -250,6 +250,74 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    /// Suggests calling `.collect()` on an `Iterator` it can be collected in the return type
+    /// ```compile_fail
+    /// let x: String = "foo".chars().map(|c| c); // with a .collect() here the code compiles
+    /// ```
+    pub(crate) fn suggest_collect(
+        &self,
+        err: &mut Diag<'_>,
+        expr: &hir::Expr<'_>,
+        expected_type: Ty<'tcx>,
+        found_type: Ty<'tcx>,
+    ) -> bool {
+        let tcx = self.tcx;
+        let expected = self.resolve_vars_if_possible(expected_type);
+        let found = self.resolve_vars_if_possible(found_type);
+
+        if expected.references_error() || found.references_error() || expected.is_unit() {
+            return false;
+        }
+
+        let Some(iterator_trait_id) = tcx.get_diagnostic_item(sym::Iterator) else {
+            return false;
+        };
+
+        if !self
+            .infcx
+            .type_implements_trait(iterator_trait_id, [found], self.param_env)
+            .must_apply_modulo_regions()
+        {
+            return false;
+        }
+
+        let Some(from_iterator_trait_id) = tcx.get_diagnostic_item(sym::FromIterator) else {
+            return false;
+        };
+
+        let Some(iterator_item_id) = tcx
+            .associated_items(iterator_trait_id)
+            .in_definition_order()
+            .find(|item| item.name() == sym::Item)
+            .map(|item| item.def_id)
+        else {
+            return false;
+        };
+
+        let item_type = Ty::new_projection(tcx, iterator_item_id, [found]);
+        let item_type =
+            self.normalize(expr.span, rustc_middle::ty::Unnormalized::new_wip(item_type));
+
+        let can_collect = self
+            .infcx
+            .type_implements_trait(from_iterator_trait_id, [expected, item_type], self.param_env)
+            .may_apply();
+
+        if can_collect {
+            err.span_suggestion_verbose(
+                expr.span.shrink_to_hi(),
+                format!(
+                    "consider using `.collect()` to convert the `Iterator` into a `{expected}`"
+                ),
+                ".collect()",
+                rustc_errors::Applicability::MaybeIncorrect,
+            );
+            return true;
+        }
+
+        false
+    }
+
     pub(crate) fn suggest_remove_last_method_call(
         &self,
         err: &mut Diag<'_>,

compiler/rustc_lint/src/lints.rs

@@ -2669,6 +2669,12 @@ pub(crate) struct RefOfMutStatic<'a> {
         "mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives"
     )]
     pub mut_note: bool,
+    #[help(
+        "use a type that relies on \"interior mutability\" instead; to read more on this, visit <https://doc.rust-lang.org/reference/interior-mutability.html>"
+    )]
+    pub interior_mutability_help: bool,
+    #[subdiagnostic]
+    pub interior_mutability_sugg: Option<StaticMutRefsInteriorMutabilitySugg>,
 }
 
 #[derive(Subdiagnostic)]
@@ -2693,6 +2699,18 @@ pub(crate) enum MutRefSugg {
     },
 }
 
+#[derive(Subdiagnostic)]
+#[suggestion(
+    "this type already provides \"interior mutability\", so its binding doesn't need to be declared as mutable",
+    style = "verbose",
+    applicability = "maybe-incorrect",
+    code = ""
+)]
+pub(crate) struct StaticMutRefsInteriorMutabilitySugg {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("`use` of a local item without leading `self::`, `super::`, or `crate::`")]
 pub(crate) struct UnqualifiedLocalImportsDiag;

compiler/rustc_lint/src/static_mut_refs.rs

@@ -1,11 +1,12 @@
 use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, Stmt};
 use rustc_middle::ty::{Mutability, TyKind};
 use rustc_session::lint::fcw;
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::{BytePos, Span};
 
-use crate::lints::{MutRefSugg, RefOfMutStatic};
+use crate::lints::{MutRefSugg, RefOfMutStatic, StaticMutRefsInteriorMutabilitySugg};
 use crate::{LateContext, LateLintPass, LintContext};
 
 declare_lint! {
@@ -67,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs {
         match expr.kind {
             hir::ExprKind::AddrOf(borrow_kind, m, ex)
                 if matches!(borrow_kind, hir::BorrowKind::Ref)
-                    && let Some(err_span) = path_is_static_mut(ex, err_span) =>
+                    && let Some(static_mut) = path_is_static_mut(ex, err_span) =>
             {
                 let source_map = cx.sess().source_map();
                 let snippet = source_map.span_to_snippet(err_span);
@@ -86,18 +87,32 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs {
                     err_span.with_hi(ex.span.lo())
                 };
 
-                emit_static_mut_refs(cx, err_span, sugg_span, m, !expr.span.from_expansion());
+                emit_static_mut_refs(
+                    cx,
+                    static_mut.err_span,
+                    sugg_span,
+                    m,
+                    !expr.span.from_expansion(),
+                    static_mut.def_id,
+                );
             }
             hir::ExprKind::MethodCall(_, e, _, _)
-                if let Some(err_span) = path_is_static_mut(e, expr.span)
+                if let Some(static_mut) = path_is_static_mut(e, expr.span)
                     && let typeck = cx.typeck_results()
                     && let Some(method_def_id) = typeck.type_dependent_def_id(expr.hir_id)
                     && let inputs =
                         cx.tcx.fn_sig(method_def_id).skip_binder().inputs().skip_binder()
                     && let Some(receiver) = inputs.get(0)
                     && let TyKind::Ref(_, _, m) = receiver.kind() =>
             {
-                emit_static_mut_refs(cx, err_span, err_span.shrink_to_lo(), *m, false);
+                emit_static_mut_refs(
+                    cx,
+                    static_mut.err_span,
+                    static_mut.err_span.shrink_to_lo(),
+                    *m,
+                    false,
+                    static_mut.def_id,
+                );
             }
             _ => {}
         }
@@ -108,14 +123,26 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs {
             && let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind
             && let hir::ByRef::Yes(_, m) = ba.0
             && let Some(init) = loc.init
-            && let Some(err_span) = path_is_static_mut(init, init.span)
+            && let Some(static_mut) = path_is_static_mut(init, init.span)
         {
-            emit_static_mut_refs(cx, err_span, err_span.shrink_to_lo(), m, false);
+            emit_static_mut_refs(
+                cx,
+                static_mut.err_span,
+                static_mut.err_span.shrink_to_lo(),
+                m,
+                false,
+                static_mut.def_id,
+            );
         }
     }
 }
 
-fn path_is_static_mut(mut expr: &hir::Expr<'_>, mut err_span: Span) -> Option<Span> {
+struct StaticMutInfo {
+    err_span: Span,
+    def_id: DefId,
+}
+
+fn path_is_static_mut(mut expr: &hir::Expr<'_>, mut err_span: Span) -> Option<StaticMutInfo> {
     if err_span.from_expansion() {
         err_span = expr.span;
     }
@@ -126,11 +153,11 @@ fn path_is_static_mut(mut expr: &hir::Expr<'_>, mut err_span: Span) -> Option<Sp
 
     if let hir::ExprKind::Path(qpath) = expr.kind
         && let hir::QPath::Resolved(_, path) = qpath
-        && let hir::def::Res::Def(def_kind, _) = path.res
+        && let hir::def::Res::Def(def_kind, def_id) = path.res
         && let hir::def::DefKind::Static { safety: _, mutability: Mutability::Mut, nested: false } =
             def_kind
     {
-        return Some(err_span);
+        return Some(StaticMutInfo { err_span, def_id });
     }
     None
 }
@@ -141,6 +168,7 @@ fn emit_static_mut_refs(
     sugg_span: Span,
     mutable: Mutability,
     suggest_addr_of: bool,
+    def_id: DefId,
 ) {
     let (shared_label, shared_note, mut_note, sugg) = match mutable {
         Mutability::Mut => {
@@ -155,9 +183,106 @@ fn emit_static_mut_refs(
         }
     };
 
+    let (interior_mutability_help, interior_mutability_sugg) =
+        interior_mutability_suggestion(cx, def_id);
+
     cx.emit_span_lint(
         STATIC_MUT_REFS,
         span,
-        RefOfMutStatic { span, sugg, shared_label, shared_note, mut_note },
+        RefOfMutStatic {
+            span,
+            sugg,
+            shared_label,
+            shared_note,
+            mut_note,
+            interior_mutability_help,
+            interior_mutability_sugg,
+        },
     );
 }
+
+// FIXME: This builds suggestion spans by handcrafting from source text.
+// Replace this with HIR-based handling once we can identify the `mut` token
+// in the static declaration that way.
+// Context: https://github.com/rust-lang/rust/pull/151362/changes#r3210767018
+fn interior_mutability_suggestion(
+    cx: &LateContext<'_>,
+    def_id: DefId,
+) -> (bool, Option<StaticMutRefsInteriorMutabilitySugg>) {
+    let static_ty = cx.tcx.type_of(def_id).skip_binder();
+    let has_interior_mutability = !static_ty.is_freeze(cx.tcx, cx.typing_env());
+
+    if !has_interior_mutability {
+        return (false, None);
+    }
+
+    let sugg =
+        static_mutability_span(cx, def_id).map(|span| StaticMutRefsInteriorMutabilitySugg { span });
+    (sugg.is_none(), sugg)
+}
+
+fn static_mutability_span(cx: &LateContext<'_>, def_id: DefId) -> Option<Span> {
+    let hir_id = cx.tcx.hir_get_if_local(def_id)?;
+    let hir::Node::Item(item) = hir_id else { return None };
+    let (mutability, ident) = match item.kind {
+        hir::ItemKind::Static(mutability, ident, _, _) => (mutability, ident),
+        _ => return None,
+    };
+    if mutability != hir::Mutability::Mut {
+        return None;
+    }
+
+    let vis_span = item.vis_span.find_ancestor_inside(item.span)?;
+    if !item.span.can_be_used_for_suggestions() || !vis_span.can_be_used_for_suggestions() {
+        return None;
+    }
+
+    let header_span = vis_span.between(ident.span);
+    if !header_span.can_be_used_for_suggestions() {
+        return None;
+    }
+
+    let source_map = cx.sess().source_map();
+    let snippet = source_map.span_to_snippet(header_span).ok()?;
+
+    let (_static_start, static_end) = find_word(&snippet, "static", 0)?;
+    let (mut_start, mut_end) = find_word(&snippet, "mut", static_end)?;
+    let mut_end = extend_trailing_space(&snippet, mut_end);
+
+    Some(
+        header_span
+            .with_lo(header_span.lo() + BytePos(mut_start as u32))
+            .with_hi(header_span.lo() + BytePos(mut_end as u32)),
+    )
+}
+
+fn find_word(snippet: &str, word: &str, start: usize) -> Option<(usize, usize)> {
+    let bytes = snippet.as_bytes();
+    let word_bytes = word.as_bytes();
+    let mut search = start;
+    while search <= snippet.len() {
+        let found = snippet[search..].find(word)?;
+        let idx = search + found;
+        let end = idx + word_bytes.len();
+        let before_ok = idx == 0 || !is_ident_char(bytes[idx - 1]);
+        let after_ok = end >= bytes.len() || !is_ident_char(bytes[end]);
+        if before_ok && after_ok {
+            return Some((idx, end));
+        }
+        search = end;
+    }
+    None
+}
+
+fn is_ident_char(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric() || byte == b'_'
+}
+
+fn extend_trailing_space(snippet: &str, mut end: usize) -> usize {
+    if let Some(ch) = snippet[end..].chars().next()
+        && (ch == ' ' || ch == '\t')
+    {
+        end += ch.len_utf8();
+    }
+    end
+}

compiler/rustc_mir_transform/src/inline.rs

@@ -1072,8 +1072,7 @@ fn make_call_args<'tcx, I: Inliner<'tcx>>(
     //
     // and the vector is `[closure_ref, tmp0, tmp1, tmp2]`.
     if callsite.fn_sig.abi() == ExternAbi::RustCall && callee_body.spread_arg.is_none() {
-        // FIXME(edition_2024): switch back to a normal method call.
-        let mut args = <_>::into_iter(args);
+        let mut args = args.into_iter();
         let self_ = create_temp_if_necessary(
             inliner,
             args.next().unwrap().node,

compiler/rustc_mir_transform/src/pass_manager.rs

@@ -296,15 +296,14 @@ fn run_passes_inner<'tcx>(
 
             if is_optimization_stage(body, phase_change, optimizations)
                 && let Some(limit) = &tcx.sess.opts.unstable_opts.mir_opt_bisect_limit
-            {
-                if limited_by_opt_bisect(
+                && limited_by_opt_bisect(
                     tcx,
                     tcx.def_path_debug_str(body.source.def_id()),
                     *limit,
                     *pass,
-                ) {
-                    continue;
-                }
+                )
+            {
+                continue;
             }
 
             let dumper = if pass.is_mir_dump_enabled()