new lint needless_raw_string + refactor a bit

Thanks, #112373, for the snippet at line 75!

CHANGELOG.md

@@ -5048,6 +5048,7 @@ Released 2018-09-13
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
+[`needless_raw_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn

clippy_lints/src/declared_lints.rs

@@ -469,7 +469,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
     crate::needless_question_mark::NEEDLESS_QUESTION_MARK_INFO,
-    crate::needless_raw_string_hashes::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::needless_update::NEEDLESS_UPDATE_INFO,
     crate::neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD_INFO,
     crate::neg_multiply::NEG_MULTIPLY_INFO,
@@ -541,6 +540,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ranges::RANGE_MINUS_ONE_INFO,
     crate::ranges::RANGE_PLUS_ONE_INFO,
     crate::ranges::REVERSED_EMPTY_RANGES_INFO,
+    crate::raw_strings::NEEDLESS_RAW_STRING_INFO,
+    crate::raw_strings::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT_INFO,
     crate::read_zero_byte_vec::READ_ZERO_BYTE_VEC_INFO,
     crate::redundant_async_block::REDUNDANT_ASYNC_BLOCK_INFO,

clippy_lints/src/lib.rs

@@ -230,7 +230,6 @@ mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
 mod needless_question_mark;
-mod needless_raw_string_hashes;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -263,6 +262,7 @@ mod pub_use;
 mod question_mark;
 mod question_mark_used;
 mod ranges;
+mod raw_strings;
 mod rc_clone_in_vec_init;
 mod read_zero_byte_vec;
 mod redundant_async_block;

clippy_lints/src/needless_raw_string_hashes.rs

@@ -1,73 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::{
-    ast::{Expr, ExprKind},
-    token::LitKind,
-};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for raw string literals with an unnecessary amount of hashes around them.
-    ///
-    /// ### Why is this bad?
-    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
-    /// necessary.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let r = r###"Hello, "world"!"###;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let r = r#"Hello, "world"!"#;
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRING_HASHES,
-    complexity,
-    "suggests reducing the number of hashes around a raw string literal"
-}
-declare_lint_pass!(NeedlessRawStringHashes => [NEEDLESS_RAW_STRING_HASHES]);
-
-impl EarlyLintPass for NeedlessRawStringHashes {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Lit(lit) = expr.kind;
-            if let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind;
-            then {
-                let str = lit.symbol.as_str();
-                let mut lowest = 0;
-
-                for i in (0..num).rev() {
-                    if str.contains(&format!("\"{}", "#".repeat(i as usize))) {
-                        lowest = i + 1;
-                        break;
-                    }
-                }
-
-                if lowest < num {
-                    let hashes = "#".repeat(lowest as usize);
-                    let prefix = match lit.kind {
-                        LitKind::StrRaw(..) => "r",
-                        LitKind::ByteStrRaw(..) => "br",
-                        LitKind::CStrRaw(..) => "cr",
-                        _ => unreachable!(),
-                    };
-
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_RAW_STRING_HASHES,
-                        expr.span,
-                        "unnecessary hashes around raw string literal",
-                        "try",
-                        format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
-                        Applicability::MachineApplicable,
-                    );
-                }
-            }
-        }
-    }
-}

clippy_lints/src/raw_strings.rs

@@ -0,0 +1,109 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use rustc_ast::{
+    ast::{Expr, ExprKind},
+    token::LitKind,
+};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals where a string literal can be used instead.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let r = r"Hello, world!";
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let r = "Hello, world!";
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING,
+    complexity,
+    "suggests using a string literal when a raw string literal is unnecessary"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals with an unnecessary amount of hashes around them.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
+    /// necessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let r = r###"Hello, "world"!"###;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let r = r#"Hello, "world"!"#;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING_HASHES,
+    complexity,
+    "suggests reducing the number of hashes around a raw string literal"
+}
+impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRING, NEEDLESS_RAW_STRING_HASHES]);
+
+pub struct RawStrings {
+    pub needless_raw_string_hashes_allow_one: bool,
+}
+
+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 prefix = match lit.kind {
+                LitKind::StrRaw(..) => "r",
+                LitKind::ByteStrRaw(..) => "br",
+                LitKind::CStrRaw(..) => "cr",
+                _ => unreachable!(),
+            };
+            if !snippet(cx, expr.span, prefix).trim().starts_with(prefix) {
+                return;
+            }
+
+            #[allow(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);
+
+            if req < num {
+                let hashes = "#".repeat(req as usize);
+
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RAW_STRING_HASHES,
+                    expr.span,
+                    "unnecessary hashes around raw string literal",
+                    "try",
+                    format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
+                    Applicability::MachineApplicable,
+                );
+            }
+
+            if !lit.symbol.as_str().contains(['\\', '"']) {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RAW_STRING,
+                    expr.span,
+                    "unnecessary raw string literal",
+                    "try",
+                    format!("{}\"{}\"", prefix.replace('r', ""), lit.symbol),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}

clippy_lints/src/utils/conf.rs

@@ -543,10 +543,14 @@ define_Conf! {
     ///
     /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
     (accept_comment_above_statement: bool = false),
-        /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
     ///
     /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
     (accept_comment_above_attributes: bool = false),
+    /// Lint: UNNECESSARY_RAW_STRING_HASHES.
+    ///
+    /// Whether to allow `r#""#` when `r""` can be used
+    (allow_one_hash_in_raw_string: bool = false),
 }
 
 /// Search for the configuration file.

clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs

@@ -35,7 +35,7 @@ struct StandardFormulations<'a> {
 impl AlmostStandardFormulation {
     pub fn new() -> Self {
         let standard_formulations = vec![StandardFormulations {
-            wrong_pattern: Regex::new(r"^(Check for|Detects? uses?)").unwrap(),
+            wrong_pattern: Regex::new("^(Check for|Detects? uses?)").unwrap(),
             correction: "Checks for",
         }];
         Self { standard_formulations }

src/main.rs

@@ -6,7 +6,7 @@ use std::env;
 use std::path::PathBuf;
 use std::process::{self, Command};
 
-const CARGO_CLIPPY_HELP: &str = r"Checks a package to catch common mistakes and improve your Rust code.
+const CARGO_CLIPPY_HELP: &str = "Checks a package to catch common mistakes and improve your Rust code.
 
 Usage:
     cargo clippy [options] [--] [<opts>...]

tests/lint_message_convention.rs

@@ -20,16 +20,16 @@ impl Message {
         // also no punctuation (except for "?" ?) at the end of a line
         static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| {
             RegexSet::new([
-                r"error: [A-Z]",
+                "error: [A-Z]",
-                r"help: [A-Z]",
+                "help: [A-Z]",
-                r"warning: [A-Z]",
+                "warning: [A-Z]",
-                r"note: [A-Z]",
+                "note: [A-Z]",
-                r"try this: [A-Z]",
+                "try this: [A-Z]",
-                r"error: .*[.!]$",
+                "error: .*[.!]$",
-                r"help: .*[.!]$",
+                "help: .*[.!]$",
-                r"warning: .*[.!]$",
+                "warning: .*[.!]$",
-                r"note: .*[.!]$",
+                "note: .*[.!]$",
-                r"try this: .*[.!]$",
+                "try this: .*[.!]$",
             ])
             .unwrap()
         });
@@ -39,11 +39,11 @@ impl Message {
         static EXCEPTIONS_SET: LazyLock<RegexSet> = LazyLock::new(|| {
             RegexSet::new([
                 r"\.\.\.$",
-                r".*C-like enum variant discriminant is not portable to 32-bit targets",
+                ".*C-like enum variant discriminant is not portable to 32-bit targets",
-                r".*Intel x86 assembly syntax used",
+                ".*Intel x86 assembly syntax used",
-                r".*AT&T x86 assembly syntax used",
+                ".*AT&T x86 assembly syntax used",
-                r"note: Clippy version: .*",
+                "note: Clippy version: .*",
-                r"the compiler unexpectedly panicked. this is a bug.",
+                "the compiler unexpectedly panicked. this is a bug.",
             ])
             .unwrap()
         });

tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs

@@ -1,5 +1,6 @@
 //@compile-flags: --crate-name conf_disallowed_methods
 
+#![allow(clippy::needless_raw_string)]
 #![warn(clippy::disallowed_methods)]
 #![allow(clippy::useless_vec)]
 

tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr

@@ -1,5 +1,5 @@
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:34:14
+  --> $DIR/conf_disallowed_methods.rs:35:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    = note: `-D clippy::disallowed-methods` implied by `-D warnings`
 
 error: use of a disallowed method `regex::Regex::is_match`
-  --> $DIR/conf_disallowed_methods.rs:35:5
+  --> $DIR/conf_disallowed_methods.rs:36:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
@@ -15,73 +15,73 @@ LL |     re.is_match("abc");
    = note: no matching allowed (from clippy.toml)
 
 error: use of a disallowed method `std::iter::Iterator::sum`
-  --> $DIR/conf_disallowed_methods.rs:38:5
+  --> $DIR/conf_disallowed_methods.rs:39:5
    |
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `slice::sort_unstable`
-  --> $DIR/conf_disallowed_methods.rs:40:5
+  --> $DIR/conf_disallowed_methods.rs:41:5
    |
 LL |     a.sort_unstable();
    |     ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:42:13
+  --> $DIR/conf_disallowed_methods.rs:43:13
    |
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:45:61
+  --> $DIR/conf_disallowed_methods.rs:46:61
    |
 LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
    |                                                             ^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:48:28
+  --> $DIR/conf_disallowed_methods.rs:49:28
    |
 LL |     let in_call = Box::new(f32::clamp);
    |                            ^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:49:53
+  --> $DIR/conf_disallowed_methods.rs:50:53
    |
 LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
    |                                                     ^^^^^^^^^^
 
 error: use of a disallowed method `futures::stream::select_all`
-  --> $DIR/conf_disallowed_methods.rs:52:31
+  --> $DIR/conf_disallowed_methods.rs:53:31
    |
 LL |     let same_name_as_module = select_all(vec![empty::<()>()]);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_fn`
-  --> $DIR/conf_disallowed_methods.rs:54:5
+  --> $DIR/conf_disallowed_methods.rs:55:5
    |
 LL |     local_fn();
    |     ^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_mod::f`
-  --> $DIR/conf_disallowed_methods.rs:55:5
+  --> $DIR/conf_disallowed_methods.rs:56:5
    |
 LL |     local_mod::f();
    |     ^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Struct::method`
-  --> $DIR/conf_disallowed_methods.rs:57:5
+  --> $DIR/conf_disallowed_methods.rs:58:5
    |
 LL |     s.method();
    |     ^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::provided_method`
-  --> $DIR/conf_disallowed_methods.rs:58:5
+  --> $DIR/conf_disallowed_methods.rs:59:5
    |
 LL |     s.provided_method();
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::implemented_method`
-  --> $DIR/conf_disallowed_methods.rs:59:5
+  --> $DIR/conf_disallowed_methods.rs:60:5
    |
 LL |     s.implemented_method();
    |     ^^^^^^^^^^^^^^^^^^^^^^

tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr

@@ -4,6 +4,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
+           allow-one-hash-in-raw-string
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
@@ -72,6 +73,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
+           allow-one-hash-in-raw-string
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests

tests/ui/format.stderr

@@ -1,5 +1,5 @@
 error: useless use of `format!`
-  --> $DIR/format.rs:20:5
+  --> $DIR/format.rs:21:5
    |
 LL |     format!("foo");
    |     ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
@@ -7,19 +7,19 @@ LL |     format!("foo");
    = note: `-D clippy::useless-format` implied by `-D warnings`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:21:5
+  --> $DIR/format.rs:22:5
    |
 LL |     format!("{{}}");
    |     ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:22:5
+  --> $DIR/format.rs:23:5
    |
 LL |     format!("{{}} abc {{}}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{} abc {}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:23:5
+  --> $DIR/format.rs:24:5
    |
 LL | /     format!(
 LL | |         r##"foo {{}}
@@ -34,67 +34,67 @@ LL ~ " bar"##.to_string();
    |
 
 error: useless use of `format!`
-  --> $DIR/format.rs:28:13
+  --> $DIR/format.rs:29:13
    |
 LL |     let _ = format!("");
    |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:30:5
+  --> $DIR/format.rs:31:5
    |
 LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:38:5
+  --> $DIR/format.rs:39:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:68:5
+  --> $DIR/format.rs:69:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:70:5
+  --> $DIR/format.rs:71:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:74:18
+  --> $DIR/format.rs:75:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:78:22
+  --> $DIR/format.rs:79:22
    |
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:84:13
+  --> $DIR/format.rs:85:13
    |
 LL |     let _ = format!("{x}");
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:86:13
+  --> $DIR/format.rs:87:13
    |
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:90:13
+  --> $DIR/format.rs:91:13
    |
 LL |     let _ = format!("{abc}");
    |             ^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `abc.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:92:13
+  --> $DIR/format.rs:93:13
    |
 LL |     let _ = format!("{xx}");
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `xx.to_string()`

tests/ui/needless_raw_string.fixed

@@ -0,0 +1,16 @@
+//@run-rustfix
+#![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string)]
+#![feature(c_str_literals)]
+
+fn main() {
+    "aaa";
+    r#""aaa""#;
+    r#"\s"#;
+    b"aaa";
+    br#""aaa""#;
+    br#"\s"#;
+    c"aaa";
+    cr#""aaa""#;
+    cr#"\s"#;
+}

tests/ui/needless_raw_string.rs

@@ -0,0 +1,16 @@
+//@run-rustfix
+#![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string)]
+#![feature(c_str_literals)]
+
+fn main() {
+    r#"aaa"#;
+    r#""aaa""#;
+    r#"\s"#;
+    br#"aaa"#;
+    br#""aaa""#;
+    br#"\s"#;
+    cr#"aaa"#;
+    cr#""aaa""#;
+    cr#"\s"#;
+}

tests/ui/needless_raw_string.stderr

@@ -0,0 +1,22 @@
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:7:5
+   |
+LL |     r#"aaa"#;
+   |     ^^^^^^^^ help: try: `"aaa"`
+   |
+   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:10:5
+   |
+LL |     br#"aaa"#;
+   |     ^^^^^^^^^ help: try: `b"aaa"`
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:13:5
+   |
+LL |     cr#"aaa"#;
+   |     ^^^^^^^^^ help: try: `c"aaa"`
+
+error: aborting due to 3 previous errors
+

tests/ui/needless_raw_string_hashes.fixed

@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::no_effect, unused)]
+#![allow(clippy::needless_raw_string, 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::no_effect, unused)]
+#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 

tests/ui/regex.rs

@@ -1,4 +1,9 @@
-#![allow(unused, clippy::needless_raw_string_hashes, clippy::needless_borrow)]
+#![allow(
+    unused,
+    clippy::needless_raw_string,
+    clippy::needless_raw_string_hashes,
+    clippy::needless_borrow
+)]
 #![warn(clippy::invalid_regex, clippy::trivial_regex)]
 
 extern crate regex;

tests/ui/regex.stderr

@@ -1,5 +1,5 @@
 error: trivial regex
-  --> $DIR/regex.rs:13:45
+  --> $DIR/regex.rs:18:45
    |
 LL |     let pipe_in_wrong_position = Regex::new("|");
    |                                             ^^^
@@ -8,7 +8,7 @@ LL |     let pipe_in_wrong_position = Regex::new("|");
    = note: `-D clippy::trivial-regex` implied by `-D warnings`
 
 error: trivial regex
-  --> $DIR/regex.rs:14:60
+  --> $DIR/regex.rs:19:60
    |
 LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    |                                                            ^^^
@@ -16,7 +16,7 @@ LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    = help: the regex is unlikely to be useful as it is
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:15:42
+  --> $DIR/regex.rs:20:42
    |
 LL |     let wrong_char_ranice = Regex::new("[z-a]");
    |                                          ^^^
@@ -24,7 +24,7 @@ LL |     let wrong_char_ranice = Regex::new("[z-a]");
    = note: `-D clippy::invalid-regex` implied by `-D warnings`
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:16:37
+  --> $DIR/regex.rs:21:37
    |
 LL |     let some_unicode = Regex::new("[é-è]");
    |                                     ^^^
@@ -33,13 +33,13 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:18:33
+  --> $DIR/regex.rs:23:33
    |
 LL |     let some_regex = Regex::new(OPENING_PAREN);
    |                                 ^^^^^^^^^^^^^
 
 error: trivial regex
-  --> $DIR/regex.rs:20:53
+  --> $DIR/regex.rs:25:53
    |
 LL |     let binary_pipe_in_wrong_position = BRegex::new("|");
    |                                                     ^^^
@@ -50,7 +50,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:21:41
+  --> $DIR/regex.rs:26:41
    |
 LL |     let some_binary_regex = BRegex::new(OPENING_PAREN);
    |                                         ^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:22:56
+  --> $DIR/regex.rs:27:56
    |
 LL |     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
    |                                                        ^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:34:37
+  --> $DIR/regex.rs:39:37
    |
 LL |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                     ^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:35:39
+  --> $DIR/regex.rs:40:39
    |
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                       ^^^^^^^^^^^^^
@@ -86,7 +86,7 @@ error: regex parse error:
            /b/c
              ^^
        error: unrecognized escape sequence
-  --> $DIR/regex.rs:42:42
+  --> $DIR/regex.rs:47:42
    |
 LL |     let escaped_string_span = Regex::new("//b//c");
    |                                          ^^^^^^^^
@@ -94,19 +94,19 @@ LL |     let escaped_string_span = Regex::new("//b//c");
    = help: consider using a raw string literal: `r".."`
 
 error: regex syntax error: duplicate flag
-  --> $DIR/regex.rs:44:34
+  --> $DIR/regex.rs:49:34
    |
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
 error: regex syntax error: pattern can match invalid UTF-8
-  --> $DIR/regex.rs:49:53
+  --> $DIR/regex.rs:54:53
    |
 LL |     let invalid_utf8_should_lint = Regex::new("(?-u).");
    |                                                     ^
 
 error: trivial regex
-  --> $DIR/regex.rs:53:33
+  --> $DIR/regex.rs:58:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -114,7 +114,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:55:48
+  --> $DIR/regex.rs:60:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:57:42
+  --> $DIR/regex.rs:62:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -130,7 +130,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:59:40
+  --> $DIR/regex.rs:64:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -138,7 +138,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:61:39
+  --> $DIR/regex.rs:66:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -146,7 +146,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:63:39
+  --> $DIR/regex.rs:68:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:65:40
+  --> $DIR/regex.rs:70:40
    |
 LL |     let trivial_backslash = Regex::new("a//.b");
    |                                        ^^^^^^^
@@ -162,7 +162,7 @@ LL |     let trivial_backslash = Regex::new("a//.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:68:36
+  --> $DIR/regex.rs:73:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -170,7 +170,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:70:36
+  --> $DIR/regex.rs:75:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -178,7 +178,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:72:36
+  --> $DIR/regex.rs:77:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -186,7 +186,7 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:74:44
+  --> $DIR/regex.rs:79:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^

tests/ui/single_char_add_str.fixed

@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {

tests/ui/single_char_add_str.rs

@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {

tests/ui/single_char_pattern.fixed

@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 

tests/ui/single_char_pattern.rs

@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 

tests/ui/write_literal_2.rs

@@ -1,5 +1,5 @@
 #![allow(unused_must_use)]
-#![warn(clippy::write_literal)]
+#![warn(clippy::needless_raw_string, clippy::write_literal)]
 
 use std::io::Write;
 

tests/ui/write_literal_2.stderr

@@ -1,3 +1,11 @@
+error: unnecessary raw string literal
+  --> $DIR/write_literal_2.rs:10:24
+   |
+LL |     writeln!(v, r"{}", r"{hello}");
+   |                        ^^^^^^^^^^ help: try: `"{hello}"`
+   |
+   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:9:23
    |
@@ -186,5 +194,5 @@ error: literal with an empty format string
 LL |     writeln!(v, r#"{}{}"#, '#', '"'); // hard mode
    |                                 ^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 18 previous errors