change category and refactor

Update raw_strings.rs

Revert "new lints for visibility"

This reverts commit 0e5a537.

new lints for visibility

Author: Centri3

clippy_lints/src/lib.rs

@@ -1063,6 +1063,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             def_id_to_usage: rustc_data_structures::fx::FxHashMap::default(),
         })
     });
+    let needless_raw_string_hashes_allow_one = conf.allow_one_hash_in_raw_string;
+    store.register_early_pass(move || {
+        Box::new(raw_strings::RawStrings {
+            needless_raw_string_hashes_allow_one,
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/raw_strings.rs

@@ -1,3 +1,5 @@
+use std::{iter::once, ops::ControlFlow};
+
 use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
 use rustc_ast::{
     ast::{Expr, ExprKind},
@@ -13,7 +15,8 @@ declare_clippy_lint! {
     /// Checks for raw string literals where a string literal can be used instead.
     ///
     /// ### Why is this bad?
-    /// It's just unnecessary.
+    /// It's just unnecessary, but there are many cases where using a raw string literal is more
+    /// idiomatic than a string literal, so it's opt-in.
     ///
     /// ### Example
     /// ```rust
@@ -25,7 +28,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_RAW_STRING,
-    complexity,
+    restriction,
     "suggests using a string literal when a raw string literal is unnecessary"
 }
 declare_clippy_lint! {
@@ -46,7 +49,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_RAW_STRING_HASHES,
-    complexity,
+    style,
     "suggests reducing the number of hashes around a raw string literal"
 }
 impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRING, NEEDLESS_RAW_STRING_HASHES]);
@@ -59,8 +62,9 @@ impl EarlyLintPass for RawStrings {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if !in_external_macro(cx.sess(), expr.span)
             && let ExprKind::Lit(lit) = expr.kind
-            && let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind
+            && let LitKind::StrRaw(max) | LitKind::ByteStrRaw(max) | LitKind::CStrRaw(max) = lit.kind
         {
+            let str = lit.symbol.as_str();
             let prefix = match lit.kind {
                 LitKind::StrRaw(..) => "r",
                 LitKind::ByteStrRaw(..) => "br",
@@ -71,7 +75,7 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
-            if !lit.symbol.as_str().contains(['\\', '"']) {
+            if !str.contains(['\\', '"']) {
                 span_lint_and_sugg(
                     cx,
                     NEEDLESS_RAW_STRING,
@@ -85,15 +89,43 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
-            #[expect(clippy::cast_possible_truncation)]
-            let req = lit.symbol.as_str().as_bytes()
-                .split(|&b| b == b'"')
-                .skip(1)
-                .map(|bs| 1 + bs.iter().take_while(|&&b| b == b'#').count() as u8)
-                .max()
-                .unwrap_or(0);
+            let req = {
+                let mut following_quote = false;
+                let mut req = 0;
+                // `once` so a raw string ending in hashes is still checked
+                let num = str.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
+                    match b {
+                        b'"' => (following_quote, req) = (true, 1),
+                        // I'm a bit surprised the compiler didn't optimize this out, there's no
+                        // branch but it still ends up doing an unnecessary comparison, it's:
+                        // - cmp r9b,1h
+                        // - sbb cl,-1h
+                        // which will add 1 if it's true. With this change, it becomes:
+                        // - add cl,r9b
+                        // isn't that so much nicer?
+                        b'#' => req += u8::from(following_quote),
+                        _ => {
+                            if following_quote {
+                                following_quote = false;
+
+                                if req == max {
+                                    return ControlFlow::Break(req);
+                                }
+
+                                return ControlFlow::Continue(acc.max(req));
+                            }
+                        },
+                    }
+
+                    ControlFlow::Continue(acc)
+                });
+
+                match num {
+                    ControlFlow::Continue(num) | ControlFlow::Break(num) => num,
+                }
+            };
 
-            if req < num {
+            if req < max {
                 let hashes = "#".repeat(req as usize);
 
                 span_lint_and_sugg(

tests/ui/needless_raw_string_hashes.fixed

@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
+#![allow(clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 

tests/ui/needless_raw_string_hashes.rs

@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
+#![allow(clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]