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_diagnostic_item;
   4 use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method_calls, paths};
   5 use clippy_utils::{peel_blocks, SpanlessEq};
   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, 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_diagnostic_item(cx, e_ty, sym::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_diagnostic_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), sym::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     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
 253         use rustc_ast::LitKind;
 254
 255         if_chain! {
 256             // Find std::str::converts::from_utf8
 257             if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
 258
 259             // Find string::as_bytes
 260             if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args[0].kind;
 261             if let ExprKind::Index(left, right) = args.kind;
 262             let (method_names, expressions, _) = method_calls(left, 1);
 263             if method_names.len() == 1;
 264             if expressions.len() == 1;
 265             if expressions[0].1.is_empty();
 266             if method_names[0] == sym!(as_bytes);
 267
 268             // Check for slicer
 269             if let ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), _, _) = right.kind;
 270
 271             then {
 272                 let mut applicability = Applicability::MachineApplicable;
 273                 let string_expression = &expressions[0].0;
 274
 275                 let snippet_app = snippet_with_applicability(
 276                     cx,
 277                     string_expression.span, "..",
 278                     &mut applicability,
 279                 );
 280
 281                 span_lint_and_sugg(
 282                     cx,
 283                     STRING_FROM_UTF8_AS_BYTES,
 284                     e.span,
 285                     "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
 286                     "try",
 287                     format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
 288                     applicability
 289                 )
 290             }
 291         }
 292
 293         if_chain! {
 294             if let ExprKind::MethodCall(path, receiver, ..) = &e.kind;
 295             if path.ident.name == sym!(as_bytes);
 296             if let ExprKind::Lit(lit) = &receiver.kind;
 297             if let LitKind::Str(lit_content, _) = &lit.node;
 298             then {
 299                 let callsite = snippet(cx, receiver.span.source_callsite(), r#""foo""#);
 300                 let mut applicability = Applicability::MachineApplicable;
 301                 if callsite.starts_with("include_str!") {
 302                     span_lint_and_sugg(
 303                         cx,
 304                         STRING_LIT_AS_BYTES,
 305                         e.span,
 306                         "calling `as_bytes()` on `include_str!(..)`",
 307                         "consider using `include_bytes!(..)` instead",
 308                         snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability).replacen(
 309                             "include_str",
 310                             "include_bytes",
 311                             1,
 312                         ),
 313                         applicability,
 314                     );
 315                 } else if lit_content.as_str().is_ascii()
 316                     && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
 317                     && !receiver.span.from_expansion()
 318                 {
 319                     span_lint_and_sugg(
 320                         cx,
 321                         STRING_LIT_AS_BYTES,
 322                         e.span,
 323                         "calling `as_bytes()` on a string literal",
 324                         "consider using a byte string literal instead",
 325                         format!(
 326                             "b{}",
 327                             snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
 328                         ),
 329                         applicability,
 330                     );
 331                 }
 332             }
 333         }
 334
 335         if_chain! {
 336             if let ExprKind::MethodCall(path, recv, [], _) = &e.kind;
 337             if path.ident.name == sym!(into_bytes);
 338             if let ExprKind::MethodCall(path, recv, [], _) = &recv.kind;
 339             if matches!(path.ident.name.as_str(), "to_owned" | "to_string");
 340             if let ExprKind::Lit(lit) = &recv.kind;
 341             if let LitKind::Str(lit_content, _) = &lit.node;
 342
 343             if lit_content.as_str().is_ascii();
 344             if lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT;
 345             if !recv.span.from_expansion();
 346             then {
 347                 let mut applicability = Applicability::MachineApplicable;
 348
 349                 span_lint_and_sugg(
 350                     cx,
 351                     STRING_LIT_AS_BYTES,
 352                     e.span,
 353                     "calling `into_bytes()` on a string literal",
 354                     "consider using a byte string literal instead",
 355                     format!(
 356                         "b{}.to_vec()",
 357                         snippet_with_applicability(cx, recv.span, r#""..""#, &mut applicability)
 358                     ),
 359                     applicability,
 360                 );
 361             }
 362         }
 363     }
 364 }
 365
 366 declare_clippy_lint! {
 367     /// ### What it does
 368     /// This lint checks for `.to_string()` method calls on values of type `&str`.
 369     ///
 370     /// ### Why is this bad?
 371     /// The `to_string` method is also used on other types to convert them to a string.
 372     /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better
 373     /// expressed with `.to_owned()`.
 374     ///
 375     /// ### Example
 376     /// ```rust
 377     /// // example code where clippy issues a warning
 378     /// let _ = "str".to_string();
 379     /// ```
 380     /// Use instead:
 381     /// ```rust
 382     /// // example code which does not raise clippy warning
 383     /// let _ = "str".to_owned();
 384     /// ```
 385     #[clippy::version = "pre 1.29.0"]
 386     pub STR_TO_STRING,
 387     restriction,
 388     "using `to_string()` on a `&str`, which should be `to_owned()`"
 389 }
 390
 391 declare_lint_pass!(StrToString => [STR_TO_STRING]);
 392
 393 impl<'tcx> LateLintPass<'tcx> for StrToString {
 394     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 395         if_chain! {
 396             if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
 397             if path.ident.name == sym::to_string;
 398             let ty = cx.typeck_results().expr_ty(self_arg);
 399             if let ty::Ref(_, ty, ..) = ty.kind();
 400             if *ty.kind() == ty::Str;
 401             then {
 402                 span_lint_and_help(
 403                     cx,
 404                     STR_TO_STRING,
 405                     expr.span,
 406                     "`to_string()` called on a `&str`",
 407                     None,
 408                     "consider using `.to_owned()`",
 409                 );
 410             }
 411         }
 412     }
 413 }
 414
 415 declare_clippy_lint! {
 416     /// ### What it does
 417     /// This lint checks for `.to_string()` method calls on values of type `String`.
 418     ///
 419     /// ### Why is this bad?
 420     /// The `to_string` method is also used on other types to convert them to a string.
 421     /// When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.
 422     ///
 423     /// ### Example
 424     /// ```rust
 425     /// // example code where clippy issues a warning
 426     /// let msg = String::from("Hello World");
 427     /// let _ = msg.to_string();
 428     /// ```
 429     /// Use instead:
 430     /// ```rust
 431     /// // example code which does not raise clippy warning
 432     /// let msg = String::from("Hello World");
 433     /// let _ = msg.clone();
 434     /// ```
 435     #[clippy::version = "pre 1.29.0"]
 436     pub STRING_TO_STRING,
 437     restriction,
 438     "using `to_string()` on a `String`, which should be `clone()`"
 439 }
 440
 441 declare_lint_pass!(StringToString => [STRING_TO_STRING]);
 442
 443 impl<'tcx> LateLintPass<'tcx> for StringToString {
 444     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 445         if_chain! {
 446             if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
 447             if path.ident.name == sym::to_string;
 448             let ty = cx.typeck_results().expr_ty(self_arg);
 449             if is_type_diagnostic_item(cx, ty, sym::String);
 450             then {
 451                 span_lint_and_help(
 452                     cx,
 453                     STRING_TO_STRING,
 454                     expr.span,
 455                     "`to_string()` called on a `String`",
 456                     None,
 457                     "consider using `.clone()`",
 458                 );
 459             }
 460         }
 461     }
 462 }
 463
 464 declare_clippy_lint! {
 465     /// ### What it does
 466     /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
 467     ///
 468     /// ### Why is this bad?
 469     /// `split_whitespace` already ignores leading and trailing whitespace.
 470     ///
 471     /// ### Example
 472     /// ```rust
 473     /// " A B C ".trim().split_whitespace();
 474     /// ```
 475     /// Use instead:
 476     /// ```rust
 477     /// " A B C ".split_whitespace();
 478     /// ```
 479     #[clippy::version = "1.62.0"]
 480     pub TRIM_SPLIT_WHITESPACE,
 481     style,
 482     "using `str::trim()` or alike before `str::split_whitespace`"
 483 }
 484 declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
 485
 486 impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
 487     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
 488         let tyckres = cx.typeck_results();
 489         if_chain! {
 490             if let ExprKind::MethodCall(path, split_recv, [], split_ws_span) = expr.kind;
 491             if path.ident.name == sym!(split_whitespace);
 492             if let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id);
 493             if cx.tcx.is_diagnostic_item(sym::str_split_whitespace, split_ws_def_id);
 494             if let ExprKind::MethodCall(path, _trim_recv, [], trim_span) = split_recv.kind;
 495             if let trim_fn_name @ ("trim" | "trim_start" | "trim_end") = path.ident.name.as_str();
 496             if let Some(trim_def_id) = tyckres.type_dependent_def_id(split_recv.hir_id);
 497             if is_one_of_trim_diagnostic_items(cx, trim_def_id);
 498             then {
 499                 span_lint_and_sugg(
 500                     cx,
 501                     TRIM_SPLIT_WHITESPACE,
 502                     trim_span.with_hi(split_ws_span.lo()),
 503                     &format!("found call to `str::{trim_fn_name}` before `str::split_whitespace`"),
 504                     &format!("remove `{trim_fn_name}()`"),
 505                     String::new(),
 506                     Applicability::MachineApplicable,
 507                 );
 508             }
 509         }
 510     }
 511 }
 512
 513 fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
 514     cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
 515         || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
 516         || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
 517 }