rust/clippy_lints/src/manual_strip.rs

use clippy_config::msrvs::{self, Msrv};
use clippy_utils::consts::{constant, Constant};
use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
use clippy_utils::source::snippet;
use clippy_utils::usage::mutated_variables;
use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
use rustc_ast::ast::LitKind;
use rustc_hir::def::Res;
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty;
use rustc_session::{declare_tool_lint, impl_lint_pass};
use rustc_span::source_map::Spanned;
use rustc_span::Span;

declare_clippy_lint! {
    /// ### What it does
    /// Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using
    /// the pattern's length.
    ///
    /// ### Why is this bad?
    /// Using `str:strip_{prefix,suffix}` is safer and may have better performance as there is no
    /// slicing which may panic and the compiler does not need to insert this panic code. It is
    /// also sometimes more readable as it removes the need for duplicating or storing the pattern
    /// used by `str::{starts,ends}_with` and in the slicing.
    ///
    /// ### Example
    /// ```no_run
    /// let s = "hello, world!";
    /// if s.starts_with("hello, ") {
    ///     assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    /// }
    /// ```
    /// Use instead:
    /// ```no_run
    /// let s = "hello, world!";
    /// if let Some(end) = s.strip_prefix("hello, ") {
    ///     assert_eq!(end.to_uppercase(), "WORLD!");
    /// }
    /// ```
    #[clippy::version = "1.48.0"]
    pub MANUAL_STRIP,
    complexity,
    "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
}

pub struct ManualStrip {
    msrv: Msrv,
}

impl ManualStrip {
    #[must_use]
    pub fn new(msrv: Msrv) -> Self {
        Self { msrv }
    }
}

impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum StripKind {
    Prefix,
    Suffix,
}

impl<'tcx> LateLintPass<'tcx> for ManualStrip {
    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
        if !self.msrv.meets(msrvs::STR_STRIP_PREFIX) {
            return;
        }

        if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
            && let ExprKind::MethodCall(_, target_arg, [pattern], _) = cond.kind
            && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
            && let ExprKind::Path(target_path) = &target_arg.kind
        {
            let strip_kind = if match_def_path(cx, method_def_id, &paths::STR_STARTS_WITH) {
                StripKind::Prefix
            } else if match_def_path(cx, method_def_id, &paths::STR_ENDS_WITH) {
                StripKind::Suffix
            } else {
                return;
            };
            let target_res = cx.qpath_res(target_path, target_arg.hir_id);
            if target_res == Res::Err {
                return;
            };

            if let Res::Local(hir_id) = target_res
                && let Some(used_mutably) = mutated_variables(then, cx)
                && used_mutably.contains(&hir_id)
            {
                return;
            }

            let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
            if !strippings.is_empty() {
                let kind_word = match strip_kind {
                    StripKind::Prefix => "prefix",
                    StripKind::Suffix => "suffix",
                };

                let test_span = expr.span.until(then.span);
                span_lint_and_then(
                    cx,
                    MANUAL_STRIP,
                    strippings[0],
                    &format!("stripping a {kind_word} manually"),
                    |diag| {
                        diag.span_note(test_span, format!("the {kind_word} was tested here"));
                        multispan_sugg(
                            diag,
                            &format!("try using the `strip_{kind_word}` method"),
                            vec![(
                                test_span,
                                format!(
                                    "if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
                                    snippet(cx, target_arg.span, ".."),
                                    snippet(cx, pattern.span, "..")
                                ),
                            )]
                            .into_iter()
                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
                        );
                    },
                );
            }
        }
    }

    extract_msrv_attr!(LateContext);
}

// Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise.
fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
    if let ExprKind::MethodCall(_, arg, [], _) = expr.kind
        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
        && match_def_path(cx, method_def_id, &paths::STR_LEN)
    {
        Some(arg)
    } else {
        None
    }
}

// Returns the length of the `expr` if it's a constant string or char.
fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
    let value = constant(cx, cx.typeck_results(), expr)?;
    match value {
        Constant::Str(value) => Some(value.len() as u128),
        Constant::Char(value) => Some(value.len_utf8() as u128),
        _ => None,
    }
}

// Tests if `expr` equals the length of the pattern.
fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
    if let ExprKind::Lit(Spanned {
        node: LitKind::Int(n, _),
        ..
    }) = expr.kind
    {
        constant_length(cx, pattern).map_or(false, |length| length == *n)
    } else {
        len_arg(cx, expr).map_or(false, |arg| eq_expr_value(cx, pattern, arg))
    }
}

// Tests if `expr` is a `&str`.
fn is_ref_str(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
    match cx.typeck_results().expr_ty_adjusted(expr).kind() {
        ty::Ref(_, ty, _) => ty.is_str(),
        _ => false,
    }
}

// Removes the outer `AddrOf` expression if needed.
fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
    if let ExprKind::AddrOf(BorrowKind::Ref, _, unref) = &expr.kind {
        unref
    } else {
        expr
    }
}

// Find expressions where `target` is stripped using the length of `pattern`.
// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
// method.
fn find_stripping<'tcx>(
    cx: &LateContext<'tcx>,
    strip_kind: StripKind,
    target: Res,
    pattern: &'tcx Expr<'_>,
    expr: &'tcx Expr<'_>,
) -> Vec<Span> {
    struct StrippingFinder<'a, 'tcx> {
        cx: &'a LateContext<'tcx>,
        strip_kind: StripKind,
        target: Res,
        pattern: &'tcx Expr<'tcx>,
        results: Vec<Span>,
    }

    impl<'a, 'tcx> Visitor<'tcx> for StrippingFinder<'a, 'tcx> {
        fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
            if is_ref_str(self.cx, ex)
                && let unref = peel_ref(ex)
                && let ExprKind::Index(indexed, index, _) = &unref.kind
                && let Some(higher::Range { start, end, .. }) = higher::Range::hir(index)
                && let ExprKind::Path(path) = &indexed.kind
                && self.cx.qpath_res(path, ex.hir_id) == self.target
            {
                match (self.strip_kind, start, end) {
                    (StripKind::Prefix, Some(start), None) => {
                        if eq_pattern_length(self.cx, self.pattern, start) {
                            self.results.push(ex.span);
                            return;
                        }
                    },
                    (StripKind::Suffix, None, Some(end)) => {
                        if let ExprKind::Binary(
                            Spanned {
                                node: BinOpKind::Sub, ..
                            },
                            left,
                            right,
                        ) = end.kind
                            && let Some(left_arg) = len_arg(self.cx, left)
                            && let ExprKind::Path(left_path) = &left_arg.kind
                            && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
                            && eq_pattern_length(self.cx, self.pattern, right)
                        {
                            self.results.push(ex.span);
                            return;
                        }
                    },
                    _ => {},
                }
            }

            walk_expr(self, ex);
        }
    }

    let mut finder = StrippingFinder {
        cx,
        strip_kind,
        target,
        pattern,
        results: vec![],
    };
    walk_expr(&mut finder, expr);
    finder.results
}