Rollup of 7 pull requests

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1254,7 +1254,7 @@ fn check_overriding_final_trait_item<'tcx>(
     trait_item: ty::AssocItem,
     impl_item: ty::AssocItem,
 ) {
-    if trait_item.defaultness(tcx).is_final() {
+    if trait_item.is_fn() && trait_item.defaultness(tcx).is_final() {
         tcx.dcx().emit_err(diagnostics::OverridingFinalTraitFunction {
             impl_span: tcx.def_span(impl_item.def_id),
             trait_span: tcx.def_span(trait_item.def_id),

compiler/rustc_resolve/src/rustdoc.rs

@@ -641,42 +641,99 @@ pub fn source_span_for_markdown_range_inner(
     let mut start_bytes = 0;
     let mut end_bytes = 0;
 
+    let span_of_all_fragments: Span = span_of_fragments(fragments)?;
+
+    let mut prev_lines_bytes = 0;
     'outer: for (line_no, md_line) in md_lines.enumerate() {
         loop {
             let source_line = src_lines.next()?;
-            match source_line.find(md_line) {
-                Some(offset) => {
-                    if line_no == starting_line {
-                        start_bytes += offset;
+            let source_line_len = u32::try_from(source_line.len()).unwrap();
+            let source_line_span =
+                span_of_all_fragments.split_at(prev_lines_bytes).1.split_at(source_line_len).0;
+            let fragment = fragments
+                .iter()
+                // `source_line_span` might contain indentation that `fragment.span` doesn't contain
+                .find(|fragment| fragment.span.overlaps(source_line_span));
+            // Since we're counting bytes, `prev_line_bytes` includes the "\n".
+            prev_lines_bytes += source_line_len + 1;
+            if let Some(fragment) = fragment
+                && let Some(offset) = source_line.find(md_line)
+            {
+                if fragment.span.lo() > source_line_span.lo()
+                    && source_line
+                        [..usize::try_from(fragment.span.lo().0 - source_line_span.lo().0).unwrap()]
+                        .chars()
+                        .any(|c| !c.is_whitespace())
+                {
+                    // Make sure anything between the start of this line and the fragment itself is just indentation.
+                    // Because source_line is built by splitting the span that covers all fragments, this only finds
+                    // characters *between* doc comments, not characters before or after doc comments.
+                    //
+                    //     1| /** doc */
+                    //     2| #[inline] /** doc2 */
+                    //        ^^^^^^^^^
+                    //        | this
+                    //
+                    //     3| fn foo() {}
+                    return None;
+                }
+                if fragment.span.hi() < source_line_span.hi()
+                    && source_line
+                        [usize::try_from(fragment.span.hi().0 - source_line_span.lo().0).unwrap()..]
+                        .chars()
+                        .any(|c| !c.is_whitespace())
+                {
+                    // Make sure anything between the start of this line and the fragment itself is just indentation.
+                    // Because source_line is built by splitting the span that covers all fragments, this only finds
+                    // characters *between* doc comments, not characters before or after doc comments.
+                    //     1| /** doc */ #[inline]
+                    //                   ^^^^^^^^^
+                    //                   | this
+                    //
+                    //     2| /** doc2 */
+                    //     3| fn foo() {}
+                    return None;
+                }
+                if line_no == starting_line {
+                    start_bytes += offset;
 
-                        if starting_line == ending_line {
-                            break 'outer;
-                        }
-                    } else if line_no == ending_line {
-                        end_bytes += offset;
+                    if starting_line == ending_line {
                         break 'outer;
-                    } else if line_no < starting_line {
-                        start_bytes += source_line.len() - md_line.len();
-                    } else {
-                        end_bytes += source_line.len() - md_line.len();
                     }
-                    break;
+                } else if line_no == ending_line {
+                    end_bytes += offset;
+                    break 'outer;
+                } else if line_no < starting_line {
+                    start_bytes += source_line.len() - md_line.len();
+                } else {
+                    end_bytes += source_line.len() - md_line.len();
                 }
-                None => {
-                    // Since this is a source line that doesn't include a markdown line,
-                    // we have to count the newline that we split from earlier.
-                    if line_no <= starting_line {
-                        start_bytes += source_line.len() + 1;
-                    } else {
-                        end_bytes += source_line.len() + 1;
-                    }
+                break;
+            } else {
+                // Since this is a source line that doesn't include a markdown line,
+                // we have to count it and its newline as non-markdown bytes.
+                if line_no <= starting_line {
+                    start_bytes += source_line.len() + 1;
+                } else if source_line.chars().any(|c| !c.is_whitespace()) {
+                    // We're past the first line, but haven't found the last line,
+                    // but we found a non-empty non-markdown line.
+                    // This could be an attribute, and we don't want a diagnostic
+                    // suggesting to delete that attribute, so we return None to be safe.
+                    //     1| /** doc */
+                    //     2 | #[inline]
+                    //          ^^^^^^^^^
+                    //          | this
+                    //     3| /** doc2 */
+                    //     4| fn foo() {}
+                    return None;
+                } else {
+                    end_bytes += source_line.len() + 1;
                 }
             }
         }
     }
 
-    let span = span_of_fragments(fragments)?;
-    let src_span = span.from_inner(InnerSpan::new(
+    let src_span = span_of_all_fragments.from_inner(InnerSpan::new(
         md_range.start + start_bytes,
         md_range.end + start_bytes + end_bytes,
     ));

compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs

@@ -1,13 +1,14 @@
 use std::fmt;
 
 use rustc_data_structures::intern::Interned;
-use rustc_errors::{Diag, IntoDiagArg};
+use rustc_errors::{Applicability, Diag, IntoDiagArg};
+use rustc_hir as hir;
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
 use rustc_middle::bug;
 use rustc_middle::ty::error::ExpectedFound;
 use rustc_middle::ty::print::{FmtPrinter, Print, PrintTraitRefExt as _, RegionHighlightMode};
-use rustc_middle::ty::{self, GenericArgsRef, RePlaceholder, Region, TyCtxt};
+use rustc_middle::ty::{self, GenericArgsRef, IsSuggestable, RePlaceholder, Region, TyCtxt};
 use tracing::{debug, instrument};
 
 use crate::diagnostics::{
@@ -379,6 +380,50 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
             }
         }
 
+        // When the mismatched trait is an Fn-trait and the self type is a closure with
+        // unannotated parameters, suggest adding explicit type annotations. This turns
+        // the confusing lifetime-generality error into an actionable hint, e.g.:
+        //   |buf|  →  |buf: &mut [u8]|
+        if self.tcx().is_fn_trait(trait_def_id) {
+            let actual_self_ty = self.cx.resolve_vars_if_possible(
+                ty::TraitRef::new_from_args(self.cx.tcx, trait_def_id, actual_args).self_ty(),
+            );
+            if let ty::Closure(closure_def_id, _) = *actual_self_ty.kind()
+                && let Some(local_def_id) = closure_def_id.as_local()
+                && let hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Closure(closure), .. }) =
+                    self.tcx().hir_node_by_def_id(local_def_id)
+            {
+                let body = self.tcx().hir_body(closure.body);
+                // For Fn traits, args[1] is the tupled input types (e.g. `(&mut [u8],)`).
+                let expected_input_tys = expected_args.type_at(1);
+                if let ty::Tuple(input_tys) = *expected_input_tys.kind() {
+                    let suggestions: Vec<_> = body
+                        .params
+                        .iter()
+                        .zip(input_tys.iter())
+                        .filter_map(|(param, ty)| {
+                            // ty_span == pat.span means no explicit type annotation was written.
+                            if param.ty_span == param.pat.span
+                                && ty.is_suggestable(self.tcx(), false)
+                            {
+                                Some((param.pat.span.shrink_to_hi(), format!(": {ty}")))
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
+                    if !suggestions.is_empty() {
+                        let msg = if suggestions.len() == 1 {
+                            "consider adding an explicit type annotation to the closure's argument"
+                        } else {
+                            "consider adding explicit type annotations to the closure's arguments"
+                        };
+                        err.multipart_suggestion(msg, suggestions, Applicability::MaybeIncorrect);
+                    }
+                }
+            }
+        }
+
         err
     }