clippy_lints/src/index_refutable_slice.rs

   1 use clippy_utils::consts::{constant, Constant};
   2 use clippy_utils::diagnostics::span_lint_and_then;
   3 use clippy_utils::higher::IfLet;
   4 use clippy_utils::ty::is_copy;
   5 use clippy_utils::{is_expn_of, is_lint_allowed, meets_msrv, msrvs, path_to_local};
   6 use if_chain::if_chain;
   7 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
   8 use rustc_errors::Applicability;
   9 use rustc_hir as hir;
  10 use rustc_hir::intravisit::{self, Visitor};
  11 use rustc_lint::{LateContext, LateLintPass};
  12 use rustc_middle::hir::nested_filter;
  13 use rustc_middle::ty;
  14 use rustc_semver::RustcVersion;
  15 use rustc_session::{declare_tool_lint, impl_lint_pass};
  16 use rustc_span::{symbol::Ident, Span};
  17
  18 declare_clippy_lint! {
  19     /// ### What it does
  20     /// The lint checks for slice bindings in patterns that are only used to
  21     /// access individual slice values.
  22     ///
  23     /// ### Why is this bad?
  24     /// Accessing slice values using indices can lead to panics. Using refutable
  25     /// patterns can avoid these. Binding to individual values also improves the
  26     /// readability as they can be named.
  27     ///
  28     /// ### Limitations
  29     /// This lint currently only checks for immutable access inside `if let`
  30     /// patterns.
  31     ///
  32     /// ### Example
  33     /// ```rust
  34     /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
  35     ///
  36     /// if let Some(slice) = slice {
  37     ///     println!("{}", slice[0]);
  38     /// }
  39     /// ```
  40     /// Use instead:
  41     /// ```rust
  42     /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
  43     ///
  44     /// if let Some(&[first, ..]) = slice {
  45     ///     println!("{}", first);
  46     /// }
  47     /// ```
  48     #[clippy::version = "1.59.0"]
  49     pub INDEX_REFUTABLE_SLICE,
  50     nursery,
  51     "avoid indexing on slices which could be destructed"
  52 }
  53
  54 #[derive(Copy, Clone)]
  55 pub struct IndexRefutableSlice {
  56     max_suggested_slice: u64,
  57     msrv: Option<RustcVersion>,
  58 }
  59
  60 impl IndexRefutableSlice {
  61     pub fn new(max_suggested_slice_pattern_length: u64, msrv: Option<RustcVersion>) -> Self {
  62         Self {
  63             max_suggested_slice: max_suggested_slice_pattern_length,
  64             msrv,
  65         }
  66     }
  67 }
  68
  69 impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
  70
  71 impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
  72     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
  73         if_chain! {
  74             if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
  75             if let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr);
  76             if !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id);
  77             if meets_msrv(self.msrv, msrvs::SLICE_PATTERNS);
  78
  79             let found_slices = find_slice_values(cx, let_pat);
  80             if !found_slices.is_empty();
  81             let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then);
  82             if !filtered_slices.is_empty();
  83             then {
  84                 for slice in filtered_slices.values() {
  85                     lint_slice(cx, slice);
  86                 }
  87             }
  88         }
  89     }
  90
  91     extract_msrv_attr!(LateContext);
  92 }
  93
  94 fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxIndexMap<hir::HirId, SliceLintInformation> {
  95     let mut removed_pat: FxHashSet<hir::HirId> = FxHashSet::default();
  96     let mut slices: FxIndexMap<hir::HirId, SliceLintInformation> = FxIndexMap::default();
  97     pat.walk_always(|pat| {
  98         if let hir::PatKind::Binding(binding, value_hir_id, ident, sub_pat) = pat.kind {
  99             // We'll just ignore mut and ref mut for simplicity sake right now
 100             if let hir::BindingAnnotation::Mutable | hir::BindingAnnotation::RefMut = binding {
 101                 return;
 102             }
 103
 104             // This block catches bindings with sub patterns. It would be hard to build a correct suggestion
 105             // for them and it's likely that the user knows what they are doing in such a case.
 106             if removed_pat.contains(&value_hir_id) {
 107                 return;
 108             }
 109             if sub_pat.is_some() {
 110                 removed_pat.insert(value_hir_id);
 111                 slices.remove(&value_hir_id);
 112                 return;
 113             }
 114
 115             let bound_ty = cx.typeck_results().node_type(pat.hir_id);
 116             if let ty::Slice(inner_ty) | ty::Array(inner_ty, _) = bound_ty.peel_refs().kind() {
 117                 // The values need to use the `ref` keyword if they can't be copied.
 118                 // This will need to be adjusted if the lint want to support mutable access in the future
 119                 let src_is_ref = bound_ty.is_ref() && binding != hir::BindingAnnotation::Ref;
 120                 let needs_ref = !(src_is_ref || is_copy(cx, *inner_ty));
 121
 122                 let slice_info = slices
 123                     .entry(value_hir_id)
 124                     .or_insert_with(|| SliceLintInformation::new(ident, needs_ref));
 125                 slice_info.pattern_spans.push(pat.span);
 126             }
 127         }
 128     });
 129
 130     slices
 131 }
 132
 133 fn lint_slice(cx: &LateContext<'_>, slice: &SliceLintInformation) {
 134     let used_indices = slice
 135         .index_use
 136         .iter()
 137         .map(|(index, _)| *index)
 138         .collect::<FxHashSet<_>>();
 139
 140     let value_name = |index| format!("{}_{}", slice.ident.name, index);
 141
 142     if let Some(max_index) = used_indices.iter().max() {
 143         let opt_ref = if slice.needs_ref { "ref " } else { "" };
 144         let pat_sugg_idents = (0..=*max_index)
 145             .map(|index| {
 146                 if used_indices.contains(&index) {
 147                     format!("{}{}", opt_ref, value_name(index))
 148                 } else {
 149                     "_".to_string()
 150                 }
 151             })
 152             .collect::<Vec<_>>();
 153         let pat_sugg = format!("[{}, ..]", pat_sugg_idents.join(", "));
 154
 155         span_lint_and_then(
 156             cx,
 157             INDEX_REFUTABLE_SLICE,
 158             slice.ident.span,
 159             "this binding can be a slice pattern to avoid indexing",
 160             |diag| {
 161                 diag.multipart_suggestion(
 162                     "try using a slice pattern here",
 163                     slice
 164                         .pattern_spans
 165                         .iter()
 166                         .map(|span| (*span, pat_sugg.clone()))
 167                         .collect(),
 168                     Applicability::MaybeIncorrect,
 169                 );
 170
 171                 diag.multipart_suggestion(
 172                     "and replace the index expressions here",
 173                     slice
 174                         .index_use
 175                         .iter()
 176                         .map(|(index, span)| (*span, value_name(*index)))
 177                         .collect(),
 178                     Applicability::MaybeIncorrect,
 179                 );
 180
 181                 // The lint message doesn't contain a warning about the removed index expression,
 182                 // since `filter_lintable_slices` will only return slices where all access indices
 183                 // are known at compile time. Therefore, they can be removed without side effects.
 184             },
 185         );
 186     }
 187 }
 188
 189 #[derive(Debug)]
 190 struct SliceLintInformation {
 191     ident: Ident,
 192     needs_ref: bool,
 193     pattern_spans: Vec<Span>,
 194     index_use: Vec<(u64, Span)>,
 195 }
 196
 197 impl SliceLintInformation {
 198     fn new(ident: Ident, needs_ref: bool) -> Self {
 199         Self {
 200             ident,
 201             needs_ref,
 202             pattern_spans: Vec::new(),
 203             index_use: Vec::new(),
 204         }
 205     }
 206 }
 207
 208 fn filter_lintable_slices<'a, 'tcx>(
 209     cx: &'a LateContext<'tcx>,
 210     slice_lint_info: FxIndexMap<hir::HirId, SliceLintInformation>,
 211     max_suggested_slice: u64,
 212     scope: &'tcx hir::Expr<'tcx>,
 213 ) -> FxIndexMap<hir::HirId, SliceLintInformation> {
 214     let mut visitor = SliceIndexLintingVisitor {
 215         cx,
 216         slice_lint_info,
 217         max_suggested_slice,
 218     };
 219
 220     intravisit::walk_expr(&mut visitor, scope);
 221
 222     visitor.slice_lint_info
 223 }
 224
 225 struct SliceIndexLintingVisitor<'a, 'tcx> {
 226     cx: &'a LateContext<'tcx>,
 227     slice_lint_info: FxIndexMap<hir::HirId, SliceLintInformation>,
 228     max_suggested_slice: u64,
 229 }
 230
 231 impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
 232     type NestedFilter = nested_filter::OnlyBodies;
 233
 234     fn nested_visit_map(&mut self) -> Self::Map {
 235         self.cx.tcx.hir()
 236     }
 237
 238     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
 239         if let Some(local_id) = path_to_local(expr) {
 240             let Self {
 241                 cx,
 242                 ref mut slice_lint_info,
 243                 max_suggested_slice,
 244             } = *self;
 245
 246             if_chain! {
 247                 // Check if this is even a local we're interested in
 248                 if let Some(use_info) = slice_lint_info.get_mut(&local_id);
 249
 250                 let map = cx.tcx.hir();
 251
 252                 // Checking for slice indexing
 253                 let parent_id = map.get_parent_node(expr.hir_id);
 254                 if let Some(hir::Node::Expr(parent_expr)) = map.find(parent_id);
 255                 if let hir::ExprKind::Index(_, index_expr) = parent_expr.kind;
 256                 if let Some((Constant::Int(index_value), _)) = constant(cx, cx.typeck_results(), index_expr);
 257                 if let Ok(index_value) = index_value.try_into();
 258                 if index_value < max_suggested_slice;
 259
 260                 // Make sure that this slice index is read only
 261                 let maybe_addrof_id = map.get_parent_node(parent_id);
 262                 if let Some(hir::Node::Expr(maybe_addrof_expr)) = map.find(maybe_addrof_id);
 263                 if let hir::ExprKind::AddrOf(_kind, hir::Mutability::Not, _inner_expr) = maybe_addrof_expr.kind;
 264                 then {
 265                     use_info.index_use.push((index_value, map.span(parent_expr.hir_id)));
 266                     return;
 267                 }
 268             }
 269
 270             // The slice was used for something other than indexing
 271             self.slice_lint_info.remove(&local_id);
 272         }
 273         intravisit::walk_expr(self, expr);
 274     }
 275 }