src/tools/clippy/clippy_lints/src/useless_conversion.rs

   1 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
   2 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
   3 use clippy_utils::sugg::Sugg;
   4 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
   5 use clippy_utils::{get_parent_expr, match_def_path, match_trait_method, paths};
   6 use if_chain::if_chain;
   7 use rustc_errors::Applicability;
   8 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
   9 use rustc_lint::{LateContext, LateLintPass};
  10 use rustc_middle::ty;
  11 use rustc_session::{declare_tool_lint, impl_lint_pass};
  12 use rustc_span::sym;
  13
  14 declare_clippy_lint! {
  15     /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls
  16     /// which uselessly convert to the same type.
  17     ///
  18     /// **Why is this bad?** Redundant code.
  19     ///
  20     /// **Known problems:** None.
  21     ///
  22     /// **Example:**
  23     ///
  24     /// ```rust
  25     /// // Bad
  26     /// // format!() returns a `String`
  27     /// let s: String = format!("hello").into();
  28     ///
  29     /// // Good
  30     /// let s: String = format!("hello");
  31     /// ```
  32     pub USELESS_CONVERSION,
  33     complexity,
  34     "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type"
  35 }
  36
  37 #[derive(Default)]
  38 pub struct UselessConversion {
  39     try_desugar_arm: Vec<HirId>,
  40 }
  41
  42 impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
  43
  44 #[allow(clippy::too_many_lines)]
  45 impl<'tcx> LateLintPass<'tcx> for UselessConversion {
  46     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  47         if e.span.from_expansion() {
  48             return;
  49         }
  50
  51         if Some(&e.hir_id) == self.try_desugar_arm.last() {
  52             return;
  53         }
  54
  55         match e.kind {
  56             ExprKind::Match(_, arms, MatchSource::TryDesugar) => {
  57                 let e = match arms[0].body.kind {
  58                     ExprKind::Ret(Some(e)) | ExprKind::Break(_, Some(e)) => e,
  59                     _ => return,
  60                 };
  61                 if let ExprKind::Call(_, args) = e.kind {
  62                     self.try_desugar_arm.push(args[0].hir_id);
  63                 }
  64             },
  65
  66             ExprKind::MethodCall(name, .., args, _) => {
  67                 if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
  68                     let a = cx.typeck_results().expr_ty(e);
  69                     let b = cx.typeck_results().expr_ty(&args[0]);
  70                     if same_type_and_consts(a, b) {
  71                         let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
  72                         span_lint_and_sugg(
  73                             cx,
  74                             USELESS_CONVERSION,
  75                             e.span,
  76                             &format!("useless conversion to the same type: `{}`", b),
  77                             "consider removing `.into()`",
  78                             sugg,
  79                             Applicability::MachineApplicable, // snippet
  80                         );
  81                     }
  82                 }
  83                 if match_trait_method(cx, e, &paths::INTO_ITERATOR) && name.ident.name == sym::into_iter {
  84                     if let Some(parent_expr) = get_parent_expr(cx, e) {
  85                         if let ExprKind::MethodCall(parent_name, ..) = parent_expr.kind {
  86                             if parent_name.ident.name != sym::into_iter {
  87                                 return;
  88                             }
  89                         }
  90                     }
  91                     let a = cx.typeck_results().expr_ty(e);
  92                     let b = cx.typeck_results().expr_ty(&args[0]);
  93                     if same_type_and_consts(a, b) {
  94                         let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
  95                         span_lint_and_sugg(
  96                             cx,
  97                             USELESS_CONVERSION,
  98                             e.span,
  99                             &format!("useless conversion to the same type: `{}`", b),
 100                             "consider removing `.into_iter()`",
 101                             sugg,
 102                             Applicability::MachineApplicable, // snippet
 103                         );
 104                     }
 105                 }
 106                 if_chain! {
 107                     if match_trait_method(cx, e, &paths::TRY_INTO_TRAIT) && name.ident.name == sym::try_into;
 108                     let a = cx.typeck_results().expr_ty(e);
 109                     let b = cx.typeck_results().expr_ty(&args[0]);
 110                     if is_type_diagnostic_item(cx, a, sym::result_type);
 111                     if let ty::Adt(_, substs) = a.kind();
 112                     if let Some(a_type) = substs.types().next();
 113                     if same_type_and_consts(a_type, b);
 114
 115                     then {
 116                         span_lint_and_help(
 117                             cx,
 118                             USELESS_CONVERSION,
 119                             e.span,
 120                             &format!("useless conversion to the same type: `{}`", b),
 121                             None,
 122                             "consider removing `.try_into()`",
 123                         );
 124                     }
 125                 }
 126             },
 127
 128             ExprKind::Call(path, args) => {
 129                 if_chain! {
 130                     if args.len() == 1;
 131                     if let ExprKind::Path(ref qpath) = path.kind;
 132                     if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
 133                     then {
 134                         let a = cx.typeck_results().expr_ty(e);
 135                         let b = cx.typeck_results().expr_ty(&args[0]);
 136                         if_chain! {
 137                             if match_def_path(cx, def_id, &paths::TRY_FROM);
 138                             if is_type_diagnostic_item(cx, a, sym::result_type);
 139                             if let ty::Adt(_, substs) = a.kind();
 140                             if let Some(a_type) = substs.types().next();
 141                             if same_type_and_consts(a_type, b);
 142
 143                             then {
 144                                 let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
 145                                 span_lint_and_help(
 146                                     cx,
 147                                     USELESS_CONVERSION,
 148                                     e.span,
 149                                     &format!("useless conversion to the same type: `{}`", b),
 150                                     None,
 151                                     &hint,
 152                                 );
 153                             }
 154                         }
 155
 156                         if_chain! {
 157                             if match_def_path(cx, def_id, &paths::FROM_FROM);
 158                             if same_type_and_consts(a, b);
 159
 160                             then {
 161                                 let sugg = Sugg::hir_with_macro_callsite(cx, &args[0], "<expr>").maybe_par();
 162                                 let sugg_msg =
 163                                     format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
 164                                 span_lint_and_sugg(
 165                                     cx,
 166                                     USELESS_CONVERSION,
 167                                     e.span,
 168                                     &format!("useless conversion to the same type: `{}`", b),
 169                                     &sugg_msg,
 170                                     sugg.to_string(),
 171                                     Applicability::MachineApplicable, // snippet
 172                                 );
 173                             }
 174                         }
 175                     }
 176                 }
 177             },
 178
 179             _ => {},
 180         }
 181     }
 182
 183     fn check_expr_post(&mut self, _: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
 184         if Some(&e.hir_id) == self.try_desugar_arm.last() {
 185             self.try_desugar_arm.pop();
 186         }
 187     }
 188 }