src/tools/clippy/clippy_lints/src/strings.rs

   1 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
   2 use clippy_utils::source::{snippet, snippet_with_applicability};
   3 use clippy_utils::ty::is_type_lang_item;
   4 use clippy_utils::{get_expr_use_or_unification_node, peel_blocks, SpanlessEq};
   5 use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method_calls, paths};
   6 use if_chain::if_chain;
   7 use rustc_errors::Applicability;
   8 use rustc_hir::def_id::DefId;
   9 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, Node, QPath};
  10 use rustc_lint::{LateContext, LateLintPass, LintContext};
  11 use rustc_middle::lint::in_external_macro;
  12 use rustc_middle::ty;
  13 use rustc_session::{declare_lint_pass, declare_tool_lint};
  14 use rustc_span::source_map::Spanned;
  15 use rustc_span::sym;
  16
  17 declare_clippy_lint! {
  18     /// ### What it does
  19     /// Checks for string appends of the form `x = x + y` (without
  20     /// `let`!).
  21     ///
  22     /// ### Why is this bad?
  23     /// It's not really bad, but some people think that the
  24     /// `.push_str(_)` method is more readable.
  25     ///
  26     /// ### Example
  27     /// ```rust
  28     /// let mut x = "Hello".to_owned();
  29     /// x = x + ", World";
  30     ///
  31     /// // More readable
  32     /// x += ", World";
  33     /// x.push_str(", World");
  34     /// ```
  35     #[clippy::version = "pre 1.29.0"]
  36     pub STRING_ADD_ASSIGN,
  37     pedantic,
  38     "using `x = x + ..` where x is a `String` instead of `push_str()`"
  39 }
  40
  41 declare_clippy_lint! {
  42     /// ### What it does
  43     /// Checks for all instances of `x + _` where `x` is of type
  44     /// `String`, but only if [`string_add_assign`](#string_add_assign) does *not*
  45     /// match.
  46     ///
  47     /// ### Why is this bad?
  48     /// It's not bad in and of itself. However, this particular
  49     /// `Add` implementation is asymmetric (the other operand need not be `String`,
  50     /// but `x` does), while addition as mathematically defined is symmetric, also
  51     /// the `String::push_str(_)` function is a perfectly good replacement.
  52     /// Therefore, some dislike it and wish not to have it in their code.
  53     ///
  54     /// That said, other people think that string addition, having a long tradition
  55     /// in other languages is actually fine, which is why we decided to make this
  56     /// particular lint `allow` by default.
  57     ///
  58     /// ### Example
  59     /// ```rust
  60     /// let x = "Hello".to_owned();
  61     /// x + ", World";
  62     /// ```
  63     ///
  64     /// Use instead:
  65     /// ```rust
  66     /// let mut x = "Hello".to_owned();
  67     /// x.push_str(", World");
  68     /// ```
  69     #[clippy::version = "pre 1.29.0"]
  70     pub STRING_ADD,
  71     restriction,
  72     "using `x + ..` where x is a `String` instead of `push_str()`"
  73 }
  74
  75 declare_clippy_lint! {
  76     /// ### What it does
  77     /// Checks for the `as_bytes` method called on string literals
  78     /// that contain only ASCII characters.
  79     ///
  80     /// ### Why is this bad?
  81     /// Byte string literals (e.g., `b"foo"`) can be used
  82     /// instead. They are shorter but less discoverable than `as_bytes()`.
  83     ///
  84     /// ### Known problems
  85     /// `"str".as_bytes()` and the suggested replacement of `b"str"` are not
  86     /// equivalent because they have different types. The former is `&[u8]`
  87     /// while the latter is `&[u8; 3]`. That means in general they will have a
  88     /// different set of methods and different trait implementations.
  89     ///
  90     /// ```compile_fail
  91     /// fn f(v: Vec<u8>) {}
  92     ///
  93     /// f("...".as_bytes().to_owned()); // works
  94     /// f(b"...".to_owned()); // does not work, because arg is [u8; 3] not Vec<u8>
  95     ///
  96     /// fn g(r: impl std::io::Read) {}
  97     ///
  98     /// g("...".as_bytes()); // works
  99     /// g(b"..."); // does not work
 100     /// ```
 101     ///
 102     /// The actual equivalent of `"str".as_bytes()` with the same type is not
 103     /// `b"str"` but `&b"str"[..]`, which is a great deal of punctuation and not
 104     /// more readable than a function call.
 105     ///
 106     /// ### Example
 107     /// ```rust
 108     /// let bstr = "a byte string".as_bytes();
 109     /// ```
 110     ///
 111     /// Use instead:
 112     /// ```rust
 113     /// let bstr = b"a byte string";
 114     /// ```
 115     #[clippy::version = "pre 1.29.0"]
 116     pub STRING_LIT_AS_BYTES,
 117     nursery,
 118     "calling `as_bytes` on a string literal instead of using a byte string literal"
 119 }
 120
 121 declare_clippy_lint! {
 122     /// ### What it does
 123     /// Checks for slice operations on strings
 124     ///
 125     /// ### Why is this bad?
 126     /// UTF-8 characters span multiple bytes, and it is easy to inadvertently confuse character
 127     /// counts and string indices. This may lead to panics, and should warrant some test cases
 128     /// containing wide UTF-8 characters. This lint is most useful in code that should avoid
 129     /// panics at all costs.
 130     ///
 131     /// ### Known problems
 132     /// Probably lots of false positives. If an index comes from a known valid position (e.g.
 133     /// obtained via `char_indices` over the same string), it is totally OK.
 134     ///
 135     /// # Example
 136     /// ```rust,should_panic
 137     /// &"Ölkanne"[1..];
 138     /// ```
 139     #[clippy::version = "1.58.0"]
 140     pub STRING_SLICE,
 141     restriction,
 142     "slicing a string"
 143 }
 144
 145 declare_lint_pass!(StringAdd => [STRING_ADD, STRING_ADD_ASSIGN, STRING_SLICE]);
 146
 147 impl<'tcx> LateLintPass<'tcx> for StringAdd {
 148     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
 149         if in_external_macro(cx.sess(), e.span) {
 150             return;
 151         }
 152         match e.kind {
 153             ExprKind::Binary(
 154                 Spanned {
 155                     node: BinOpKind::Add, ..
 156                 },
 157                 left,
 158                 _,
 159             ) => {
 160                 if is_string(cx, left) {
 161                     if !is_lint_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
 162                         let parent = get_parent_expr(cx, e);
 163                         if let Some(p) = parent {
 164                             if let ExprKind::Assign(target, _, _) = p.kind {
 165                                 // avoid duplicate matches
 166                                 if SpanlessEq::new(cx).eq_expr(target, left) {
 167                                     return;
 168                                 }
 169                             }
 170                         }
 171                     }
 172                     span_lint(
 173                         cx,
 174                         STRING_ADD,
 175                         e.span,
 176                         "you added something to a string. Consider using `String::push_str()` instead",
 177                     );
 178                 }
 179             },
 180             ExprKind::Assign(target, src, _) => {
 181                 if is_string(cx, target) && is_add(cx, src, target) {
 182                     span_lint(
 183                         cx,
 184                         STRING_ADD_ASSIGN,
 185                         e.span,
 186                         "you assigned the result of adding something to this string. Consider using \
 187                          `String::push_str()` instead",
 188                     );
 189                 }
 190             },
 191             ExprKind::Index(target, _idx) => {
 192                 let e_ty = cx.typeck_results().expr_ty(target).peel_refs();
 193                 if matches!(e_ty.kind(), ty::Str) || is_type_lang_item(cx, e_ty, LangItem::String) {
 194                     span_lint(
 195                         cx,
 196                         STRING_SLICE,
 197                         e.span,
 198                         "indexing into a string may panic if the index is within a UTF-8 character",
 199                     );
 200                 }
 201             },
 202             _ => {},
 203         }
 204     }
 205 }
 206
 207 fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 208     is_type_lang_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), LangItem::String)
 209 }
 210
 211 fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
 212     match peel_blocks(src).kind {
 213         ExprKind::Binary(
 214             Spanned {
 215                 node: BinOpKind::Add, ..
 216             },
 217             left,
 218             _,
 219         ) => SpanlessEq::new(cx).eq_expr(target, left),
 220         _ => false,
 221     }
 222 }
 223
 224 declare_clippy_lint! {
 225     /// ### What it does
 226     /// Check if the string is transformed to byte array and casted back to string.
 227     ///
 228     /// ### Why is this bad?
 229     /// It's unnecessary, the string can be used directly.
 230     ///
 231     /// ### Example
 232     /// ```rust
 233     /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
 234     /// ```
 235     ///
 236     /// Use instead:
 237     /// ```rust
 238     /// &"Hello World!"[6..11];
 239     /// ```
 240     #[clippy::version = "1.50.0"]
 241     pub STRING_FROM_UTF8_AS_BYTES,
 242     complexity,
 243     "casting string slices to byte slices and back"
 244 }
 245
 246 // Max length a b"foo" string can take
 247 const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 248
 249 declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
 250
 251 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
 252     #[expect(clippy::too_many_lines)]
 253     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
 254         use rustc_ast::LitKind;
 255
 256         if_chain! {
 257             // Find std::str::converts::from_utf8
 258             if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
 259
 260             // Find string::as_bytes
 261             if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args[0].kind;
 262             if let ExprKind::Index(left, right) = args.kind;
 263             let (method_names, expressions, _) = method_calls(left, 1);
 264             if method_names.len() == 1;
 265             if expressions.len() == 1;
 266             if expressions[0].1.is_empty();
 267             if method_names[0] == sym!(as_bytes);
 268
 269             // Check for slicer
 270             if let ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), _, _) = right.kind;
 271
 272             then {
 273                 let mut applicability = Applicability::MachineApplicable;
 274                 let string_expression = &expressions[0].0;
 275
 276                 let snippet_app = snippet_with_applicability(
 277                     cx,
 278                     string_expression.span, "..",
 279                     &mut applicability,
 280                 );
 281
 282                 span_lint_and_sugg(
 283                     cx,
 284                     STRING_FROM_UTF8_AS_BYTES,
 285                     e.span,
 286                     "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
 287                     "try",
 288                     format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
 289                     applicability
 290                 )
 291             }
 292         }
 293
 294         if_chain! {
 295             if let ExprKind::MethodCall(path, receiver, ..) = &e.kind;
 296             if path.ident.name == sym!(as_bytes);
 297             if let ExprKind::Lit(lit) = &receiver.kind;
 298             if let LitKind::Str(lit_content, _) = &lit.node;
 299             then {
 300                 let callsite = snippet(cx, receiver.span.source_callsite(), r#""foo""#);
 301                 let mut applicability = Applicability::MachineApplicable;
 302                 if callsite.starts_with("include_str!") {
 303                     span_lint_and_sugg(
 304                         cx,
 305                         STRING_LIT_AS_BYTES,
 306                         e.span,
 307                         "calling `as_bytes()` on `include_str!(..)`",
 308                         "consider using `include_bytes!(..)` instead",
 309                         snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability).replacen(
 310                             "include_str",
 311                             "include_bytes",
 312                             1,
 313                         ),
 314                         applicability,
 315                     );
 316                 } else if lit_content.as_str().is_ascii()
 317                     && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
 318                     && !receiver.span.from_expansion()
 319                 {
 320                     if let Some((parent, id)) = get_expr_use_or_unification_node(cx.tcx, e)
 321                         && let Node::Expr(parent) = parent
 322                         && let ExprKind::Match(scrutinee, ..) = parent.kind
 323                         && scrutinee.hir_id == id
 324                     {
 325                         // Don't lint. Byte strings produce `&[u8; N]` whereas `as_bytes()` produces
 326                         // `&[u8]`. This change would prevent matching with different sized slices.
 327                     } else {
 328                         span_lint_and_sugg(
 329                             cx,
 330                             STRING_LIT_AS_BYTES,
 331                             e.span,
 332                             "calling `as_bytes()` on a string literal",
 333                             "consider using a byte string literal instead",
 334                             format!(
 335                                 "b{}",
 336                                 snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
 337                             ),
 338                             applicability,
 339                         );
 340                     }
 341                 }
 342             }
 343         }
 344
 345         if_chain! {
 346             if let ExprKind::MethodCall(path, recv, [], _) = &e.kind;
 347             if path.ident.name == sym!(into_bytes);
 348             if let ExprKind::MethodCall(path, recv, [], _) = &recv.kind;
 349             if matches!(path.ident.name.as_str(), "to_owned" | "to_string");
 350             if let ExprKind::Lit(lit) = &recv.kind;
 351             if let LitKind::Str(lit_content, _) = &lit.node;
 352
 353             if lit_content.as_str().is_ascii();
 354             if lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT;
 355             if !recv.span.from_expansion();
 356             then {
 357                 let mut applicability = Applicability::MachineApplicable;
 358
 359                 span_lint_and_sugg(
 360                     cx,
 361                     STRING_LIT_AS_BYTES,
 362                     e.span,
 363                     "calling `into_bytes()` on a string literal",
 364                     "consider using a byte string literal instead",
 365                     format!(
 366                         "b{}.to_vec()",
 367                         snippet_with_applicability(cx, recv.span, r#""..""#, &mut applicability)
 368                     ),
 369                     applicability,
 370                 );
 371             }
 372         }
 373     }
 374 }
 375
 376 declare_clippy_lint! {
 377     /// ### What it does
 378     /// This lint checks for `.to_string()` method calls on values of type `&str`.
 379     ///
 380     /// ### Why is this bad?
 381     /// The `to_string` method is also used on other types to convert them to a string.
 382     /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better
 383     /// expressed with `.to_owned()`.
 384     ///
 385     /// ### Example
 386     /// ```rust
 387     /// // example code where clippy issues a warning
 388     /// let _ = "str".to_string();
 389     /// ```
 390     /// Use instead:
 391     /// ```rust
 392     /// // example code which does not raise clippy warning
 393     /// let _ = "str".to_owned();
 394     /// ```
 395     #[clippy::version = "pre 1.29.0"]
 396     pub STR_TO_STRING,
 397     restriction,
 398     "using `to_string()` on a `&str`, which should be `to_owned()`"
 399 }
 400
 401 declare_lint_pass!(StrToString => [STR_TO_STRING]);
 402
 403 impl<'tcx> LateLintPass<'tcx> for StrToString {
 404     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 405         if_chain! {
 406             if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
 407             if path.ident.name == sym::to_string;
 408             let ty = cx.typeck_results().expr_ty(self_arg);
 409             if let ty::Ref(_, ty, ..) = ty.kind();
 410             if *ty.kind() == ty::Str;
 411             then {
 412                 span_lint_and_help(
 413                     cx,
 414                     STR_TO_STRING,
 415                     expr.span,
 416                     "`to_string()` called on a `&str`",
 417                     None,
 418                     "consider using `.to_owned()`",
 419                 );
 420             }
 421         }
 422     }
 423 }
 424
 425 declare_clippy_lint! {
 426     /// ### What it does
 427     /// This lint checks for `.to_string()` method calls on values of type `String`.
 428     ///
 429     /// ### Why is this bad?
 430     /// The `to_string` method is also used on other types to convert them to a string.
 431     /// When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.
 432     ///
 433     /// ### Example
 434     /// ```rust
 435     /// // example code where clippy issues a warning
 436     /// let msg = String::from("Hello World");
 437     /// let _ = msg.to_string();
 438     /// ```
 439     /// Use instead:
 440     /// ```rust
 441     /// // example code which does not raise clippy warning
 442     /// let msg = String::from("Hello World");
 443     /// let _ = msg.clone();
 444     /// ```
 445     #[clippy::version = "pre 1.29.0"]
 446     pub STRING_TO_STRING,
 447     restriction,
 448     "using `to_string()` on a `String`, which should be `clone()`"
 449 }
 450
 451 declare_lint_pass!(StringToString => [STRING_TO_STRING]);
 452
 453 impl<'tcx> LateLintPass<'tcx> for StringToString {
 454     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 455         if_chain! {
 456             if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
 457             if path.ident.name == sym::to_string;
 458             let ty = cx.typeck_results().expr_ty(self_arg);
 459             if is_type_lang_item(cx, ty, LangItem::String);
 460             then {
 461                 span_lint_and_help(
 462                     cx,
 463                     STRING_TO_STRING,
 464                     expr.span,
 465                     "`to_string()` called on a `String`",
 466                     None,
 467                     "consider using `.clone()`",
 468                 );
 469             }
 470         }
 471     }
 472 }
 473
 474 declare_clippy_lint! {
 475     /// ### What it does
 476     /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
 477     ///
 478     /// ### Why is this bad?
 479     /// `split_whitespace` already ignores leading and trailing whitespace.
 480     ///
 481     /// ### Example
 482     /// ```rust
 483     /// " A B C ".trim().split_whitespace();
 484     /// ```
 485     /// Use instead:
 486     /// ```rust
 487     /// " A B C ".split_whitespace();
 488     /// ```
 489     #[clippy::version = "1.62.0"]
 490     pub TRIM_SPLIT_WHITESPACE,
 491     style,
 492     "using `str::trim()` or alike before `str::split_whitespace`"
 493 }
 494 declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
 495
 496 impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
 497     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 498         let tyckres = cx.typeck_results();
 499         if_chain! {
 500             if let ExprKind::MethodCall(path, split_recv, [], split_ws_span) = expr.kind;
 501             if path.ident.name == sym!(split_whitespace);
 502             if let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id);
 503             if cx.tcx.is_diagnostic_item(sym::str_split_whitespace, split_ws_def_id);
 504             if let ExprKind::MethodCall(path, _trim_recv, [], trim_span) = split_recv.kind;
 505             if let trim_fn_name @ ("trim" | "trim_start" | "trim_end") = path.ident.name.as_str();
 506             if let Some(trim_def_id) = tyckres.type_dependent_def_id(split_recv.hir_id);
 507             if is_one_of_trim_diagnostic_items(cx, trim_def_id);
 508             then {
 509                 span_lint_and_sugg(
 510                     cx,
 511                     TRIM_SPLIT_WHITESPACE,
 512                     trim_span.with_hi(split_ws_span.lo()),
 513                     &format!("found call to `str::{trim_fn_name}` before `str::split_whitespace`"),
 514                     &format!("remove `{trim_fn_name}()`"),
 515                     String::new(),
 516                     Applicability::MachineApplicable,
 517                 );
 518             }
 519         }
 520     }
 521 }
 522
 523 fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
 524     cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
 525         || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
 526         || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
 527 }