Rustup (rust-lang#16299)

r? @ghost

changelog: none

Author: flip1995

clippy_dev/Cargo.toml

@@ -10,6 +10,7 @@ clap = { version = "4.4", features = ["derive"] }
 indoc = "1.0"
 itertools = "0.12"
 opener = "0.7"
+rustc-literal-escaper = "0.0.5"
 walkdir = "2.3"
 
 [package.metadata.rust-analyzer]

clippy_dev/src/lib.rs

@@ -22,7 +22,6 @@ extern crate rustc_arena;
 #[expect(unused_extern_crates, reason = "required to link to rustc crates")]
 extern crate rustc_driver;
 extern crate rustc_lexer;
-extern crate rustc_literal_escaper;
 
 pub mod deprecate_lint;
 pub mod dogfood;

clippy_lints/src/doc/doc_suspicious_footnotes.rs

@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::attr::AttributeExt as _;
-use rustc_ast::token::CommentKind;
+use rustc_ast::token::{CommentKind, DocFragmentKind};
 use rustc_errors::Applicability;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::{AttrStyle, Attribute};
 use rustc_lint::{LateContext, LintContext};
-use rustc_resolve::rustdoc::DocFragmentKind;
 
 use std::ops::Range;
 
@@ -43,13 +43,24 @@ pub fn check(cx: &LateContext<'_>, doc: &str, range: Range<usize>, fragments: &F
                 span,
                 "looks like a footnote ref, but has no matching footnote",
                 |diag| {
-                    if this_fragment.kind == DocFragmentKind::SugaredDoc {
-                        let (doc_attr, (_, doc_attr_comment_kind), attr_style) = attrs
+                    if let DocFragmentKind::Sugared(_) = this_fragment.kind {
+                        let (doc_attr, doc_attr_comment_kind, attr_style) = attrs
                             .iter()
-                            .filter(|attr| attr.span().overlaps(this_fragment.span))
+                            .filter(|attr| {
+                                matches!(
+                                    attr,
+                                    Attribute::Parsed(AttributeKind::DocComment { span, .. })
+                                    if span.overlaps(this_fragment.span),
+                                )
+                            })
                             .rev()
                             .find_map(|attr| {
-                                Some((attr, attr.doc_str_and_comment_kind()?, attr.doc_resolution_scope()?))
+                                let (_, fragment) = attr.doc_str_and_fragment_kind()?;
+                                let fragment = match fragment {
+                                    DocFragmentKind::Sugared(kind) => kind,
+                                    DocFragmentKind::Raw(_) => CommentKind::Line,
+                                };
+                                Some((attr, fragment, attr.doc_resolution_scope()?))
                             })
                             .unwrap();
                         let (to_add, terminator) = match (doc_attr_comment_kind, attr_style) {

clippy_lints/src/doc/mod.rs

@@ -861,7 +861,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
 
     let (fragments, _) = attrs_to_doc_fragments(
         attrs.iter().filter_map(|attr| {
-            if attr.doc_str_and_comment_kind().is_none() || attr.span().in_external_macro(cx.sess().source_map()) {
+            if attr.doc_str_and_fragment_kind().is_none() || attr.span().in_external_macro(cx.sess().source_map()) {
                 None
             } else {
                 Some((attr, None))

clippy_lints/src/doc/suspicious_doc_comments.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::AttrStyle;
-use rustc_ast::token::CommentKind;
+use rustc_ast::token::{CommentKind, DocFragmentKind};
 use rustc_errors::Applicability;
 use rustc_hir::Attribute;
 use rustc_hir::attrs::AttributeKind;
@@ -39,15 +39,15 @@ fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
         .filter_map(|attr| {
             if let Attribute::Parsed(AttributeKind::DocComment {
                 style: AttrStyle::Outer,
-                kind,
+                kind: DocFragmentKind::Sugared(comment_kind),
                 comment,
                 ..
             }) = attr
                 && let Some(com) = comment.as_str().strip_prefix('!')
             {
-                let sugg = match kind {
-                    CommentKind::Line => format!("//!{com}"),
+                let sugg = match comment_kind {
                     CommentKind::Block => format!("/*!{com}*/"),
+                    CommentKind::Line => format!("//!{com}"),
                 };
                 Some((attr.span(), sugg))
             } else {

clippy_lints/src/methods/mod.rs

@@ -889,7 +889,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub SEARCH_IS_SOME,
-    complexity,
+    nursery,
     "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
 }
 

clippy_lints/src/module_style.rs

@@ -81,7 +81,7 @@ pub struct ModStyle {
 
 impl EarlyLintPass for ModStyle {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
-        self.working_dir = cx.sess().opts.working_dir.local_path().map(Path::to_path_buf);
+        self.working_dir = cx.sess().source_map().working_dir().local_path().map(Path::to_path_buf);
     }
 
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {

clippy_lints/src/utils/author.rs

@@ -319,6 +319,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 chain!(self, "let ConstArgKind::Anon({anon_const}) = {const_arg}.kind");
                 self.body(field!(anon_const.body));
             },
+            ConstArgKind::Struct(..) => chain!(self, "let ConstArgKind::Struct(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
         }

clippy_lints_internal/src/almost_standard_lint_formulation.rs

@@ -1,9 +1,11 @@
 use crate::lint_without_lint_pass::is_lint_ref_type;
 use clippy_utils::diagnostics::span_lint_and_help;
 use regex::Regex;
+use rustc_ast::token::DocFragmentKind;
 use rustc_hir::{Attribute, Item, ItemKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, Symbol};
 
 declare_tool_lint! {
     /// ### What it does
@@ -46,28 +48,22 @@ impl<'tcx> LateLintPass<'tcx> for AlmostStandardFormulation {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let mut check_next = false;
         if let ItemKind::Static(Mutability::Not, _, ty, _) = item.kind {
-            let lines = cx
-                .tcx
-                .hir_attrs(item.hir_id())
-                .iter()
-                .filter_map(|attr| Attribute::doc_str(attr).map(|sym| (sym, attr)));
+            let lines = cx.tcx.hir_attrs(item.hir_id()).iter().filter_map(doc_attr);
             if is_lint_ref_type(cx, ty) {
-                for (line, attr) in lines {
+                for (line, span) in lines {
                     let cur_line = line.as_str().trim();
                     if check_next && !cur_line.is_empty() {
                         for formulation in &self.standard_formulations {
                             let starts_with_correct_formulation = cur_line.starts_with(formulation.correction);
                             if !starts_with_correct_formulation && formulation.wrong_pattern.is_match(cur_line) {
-                                if let Some(ident) = attr.ident() {
-                                    span_lint_and_help(
-                                        cx,
-                                        ALMOST_STANDARD_LINT_FORMULATION,
-                                        ident.span,
-                                        "non-standard lint formulation",
-                                        None,
-                                        format!("consider using `{}`", formulation.correction),
-                                    );
-                                }
+                                span_lint_and_help(
+                                    cx,
+                                    ALMOST_STANDARD_LINT_FORMULATION,
+                                    span,
+                                    "non-standard lint formulation",
+                                    None,
+                                    format!("consider using `{}`", formulation.correction),
+                                );
                                 return;
                             }
                         }
@@ -84,3 +80,10 @@ impl<'tcx> LateLintPass<'tcx> for AlmostStandardFormulation {
         }
     }
 }
+
+fn doc_attr(attr: &Attribute) -> Option<(Symbol, Span)> {
+    match Attribute::doc_str_and_fragment_kind(attr) {
+        Some((symbol, DocFragmentKind::Raw(span))) => Some((symbol, span)),
+        _ => None,
+    }
+}

clippy_utils/README.md

@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-12-11
+nightly-2025-12-25
 ```
 <!-- end autogenerated nightly -->