Don't escape unicode escape braces in print_literal

Author: Alexendoo

clippy_lints/src/declared_lints.rs

@@ -573,8 +573,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ref_option_ref::REF_OPTION_REF_INFO,
     crate::ref_patterns::REF_PATTERNS_INFO,
     crate::reference::DEREF_ADDROF_INFO,
-    crate::regex::INVALID_REGEX_INFO,
-    crate::regex::TRIVIAL_REGEX_INFO,
+    crate::regular_expressions::INVALID_REGEX_INFO,
+    crate::regular_expressions::TRIVIAL_REGEX_INFO,
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,

clippy_lints/src/lib.rs

@@ -3,6 +3,7 @@
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
+#![feature(lazy_cell)]
 #![feature(let_chains)]
 #![feature(lint_reasons)]
 #![feature(never_type)]
@@ -21,6 +22,7 @@
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
+extern crate regex;
 extern crate rustc_arena;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
@@ -283,7 +285,7 @@ mod redundant_type_annotations;
 mod ref_option_ref;
 mod ref_patterns;
 mod reference;
-mod regex;
+mod regular_expressions;
 mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
@@ -726,7 +728,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
-    store.register_late_pass(|_| Box::<regex::Regex>::default());
+    store.register_late_pass(|_| Box::<regular_expressions::Regex>::default());
     let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(copies::CopyAndPaste::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));

clippy_lints/src/regex.rs renamed to clippy_lints/src/regular_expressions.rs

@@ -2,13 +2,15 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::macros::{find_format_args, format_arg_removal_span, root_macro_call_first_node, MacroCall};
 use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
+use regex::{Captures, Regex};
 use rustc_ast::token::LitKind;
 use rustc_ast::{FormatArgPosition, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, BytePos};
+use std::sync::LazyLock;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -471,9 +473,9 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
             && let rustc_ast::ExprKind::Lit(lit) = &arg.expr.kind
             && !arg.expr.span.from_expansion()
             && let Some(value_string) = snippet_opt(cx, arg.expr.span)
-    {
+        {
             let (replacement, replace_raw) = match lit.kind {
-                LitKind::Str | LitKind::StrRaw(_)  => match extract_str_literal(&value_string) {
+                LitKind::Str | LitKind::StrRaw(_) => match extract_str_literal(&value_string) {
                     Some(extracted) => extracted,
                     None => return,
                 },
@@ -519,27 +521,33 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 },
             };
 
-            span_lint_and_then(
-                cx,
-                lint,
-                arg.expr.span,
-                "literal with an empty format string",
-                |diag| {
-                    if let Some(replacement) = replacement
-                        // `format!("{}", "a")`, `format!("{named}", named = "b")
-                        //              ~~~~~                      ~~~~~~~~~~~~~
-                        && let Some(removal_span) = format_arg_removal_span(format_args, index)
-                    {
-                        let replacement = replacement.replace('{', "{{").replace('}', "}}");
-                        diag.multipart_suggestion(
-                            "try",
-                            vec![(*placeholder_span, replacement), (removal_span, String::new())],
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                },
-            );
-
+            span_lint_and_then(cx, lint, arg.expr.span, "literal with an empty format string", |diag| {
+                static ESCAPE_OR_BRACE: LazyLock<Regex> =
+                    LazyLock::new(|| Regex::new(r"\\u\{[[:xdigit:]]*\}|[{}]").unwrap());
+
+                if let Some(replacement) = replacement
+                    // `format!("{}", "a")`, `format!("{named}", named = "b")
+                    //              ~~~~~                      ~~~~~~~~~~~~~
+                    && let Some(removal_span) = format_arg_removal_span(format_args, index)
+                {
+                    let replacement = ESCAPE_OR_BRACE.replace_all(&replacement, |captures: &Captures<'_>| {
+                        match &captures[0] {
+                            "{" => "{{",
+                            "}" => "}}",
+                            escape => escape,
+                        }
+                        .to_string()
+                    });
+                    diag.multipart_suggestion(
+                        "try",
+                        vec![
+                            (*placeholder_span, replacement.into_owned()),
+                            (removal_span, String::new()),
+                        ],
+                        Applicability::MachineApplicable,
+                    );
+                }
+            });
         }
     }
 }

clippy_lints/src/write.rs

@@ -42,4 +42,7 @@ fn main() {
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
     println!("file: {}", file!());
+
+    // Braces in unicode escapes should not be escaped
+    println!("{}", "{} \u{ab123} {}");
 }

tests/ui/print_literal.rs

@@ -143,5 +143,17 @@ LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
 LL +     println!("{bar} hello", bar = "world");
    |
 
-error: aborting due to 12 previous errors
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:47:20
+   |
+LL |     println!("{}", "{} /u{ab123} {}");
+   |                    ^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", "{} /u{ab123} {}");
+LL +     println!("{{}} /u{ab123} {{}}");
+   |
+
+error: aborting due to 13 previous errors