compiler/rustc_lint/src/array_into_iter.rs

   1 use crate::{LateContext, LateLintPass, LintContext};
   2 use rustc_errors::{fluent, Applicability};
   3 use rustc_hir as hir;
   4 use rustc_middle::ty;
   5 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
   6 use rustc_session::lint::FutureIncompatibilityReason;
   7 use rustc_span::edition::Edition;
   8 use rustc_span::symbol::sym;
   9 use rustc_span::Span;
  10
  11 declare_lint! {
  12     /// The `array_into_iter` lint detects calling `into_iter` on arrays.
  13     ///
  14     /// ### Example
  15     ///
  16     /// ```rust,edition2018
  17     /// # #![allow(unused)]
  18     /// [1, 2, 3].into_iter().for_each(|n| { *n; });
  19     /// ```
  20     ///
  21     /// {{produces}}
  22     ///
  23     /// ### Explanation
  24     ///
  25     /// Since Rust 1.53, arrays implement `IntoIterator`. However, to avoid
  26     /// breakage, `array.into_iter()` in Rust 2015 and 2018 code will still
  27     /// behave as `(&array).into_iter()`, returning an iterator over
  28     /// references, just like in Rust 1.52 and earlier.
  29     /// This only applies to the method call syntax `array.into_iter()`, not to
  30     /// any other syntax such as `for _ in array` or `IntoIterator::into_iter(array)`.
  31     pub ARRAY_INTO_ITER,
  32     Warn,
  33     "detects calling `into_iter` on arrays in Rust 2015 and 2018",
  34     @future_incompatible = FutureIncompatibleInfo {
  35         reference: "<https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>",
  36         reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2021),
  37     };
  38 }
  39
  40 #[derive(Copy, Clone, Default)]
  41 pub struct ArrayIntoIter {
  42     for_expr_span: Span,
  43 }
  44
  45 impl_lint_pass!(ArrayIntoIter => [ARRAY_INTO_ITER]);
  46
  47 impl<'tcx> LateLintPass<'tcx> for ArrayIntoIter {
  48     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
  49         // Save the span of expressions in `for _ in expr` syntax,
  50         // so we can give a better suggestion for those later.
  51         if let hir::ExprKind::Match(arg, [_], hir::MatchSource::ForLoopDesugar) = &expr.kind {
  52             if let hir::ExprKind::Call(path, [arg]) = &arg.kind {
  53                 if let hir::ExprKind::Path(hir::QPath::LangItem(
  54                     hir::LangItem::IntoIterIntoIter,
  55                     ..,
  56                 )) = &path.kind
  57                 {
  58                     self.for_expr_span = arg.span;
  59                 }
  60             }
  61         }
  62
  63         // We only care about method call expressions.
  64         if let hir::ExprKind::MethodCall(call, receiver_arg, ..) = &expr.kind {
  65             if call.ident.name != sym::into_iter {
  66                 return;
  67             }
  68
  69             // Check if the method call actually calls the libcore
  70             // `IntoIterator::into_iter`.
  71             let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
  72             match cx.tcx.trait_of_item(def_id) {
  73                 Some(trait_id) if cx.tcx.is_diagnostic_item(sym::IntoIterator, trait_id) => {}
  74                 _ => return,
  75             };
  76
  77             // As this is a method call expression, we have at least one argument.
  78             let receiver_ty = cx.typeck_results().expr_ty(receiver_arg);
  79             let adjustments = cx.typeck_results().expr_adjustments(receiver_arg);
  80
  81             let Some(Adjustment { kind: Adjust::Borrow(_), target }) = adjustments.last() else {
  82                 return
  83             };
  84
  85             let types =
  86                 std::iter::once(receiver_ty).chain(adjustments.iter().map(|adj| adj.target));
  87
  88             let mut found_array = false;
  89
  90             for ty in types {
  91                 match ty.kind() {
  92                     // If we run into a &[T; N] or &[T] first, there's nothing to warn about.
  93                     // It'll resolve to the reference version.
  94                     ty::Ref(_, inner_ty, _) if inner_ty.is_array() => return,
  95                     ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), ty::Slice(..)) => return,
  96                     // Found an actual array type without matching a &[T; N] first.
  97                     // This is the problematic case.
  98                     ty::Array(..) => {
  99                         found_array = true;
 100                         break;
 101                     }
 102                     _ => {}
 103                 }
 104             }
 105
 106             if !found_array {
 107                 return;
 108             }
 109
 110             // Emit lint diagnostic.
 111             let target = match *target.kind() {
 112                 ty::Ref(_, inner_ty, _) if inner_ty.is_array() => "[T; N]",
 113                 ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), ty::Slice(..)) => "[T]",
 114                 // We know the original first argument type is an array type,
 115                 // we know that the first adjustment was an autoref coercion
 116                 // and we know that `IntoIterator` is the trait involved. The
 117                 // array cannot be coerced to something other than a reference
 118                 // to an array or to a slice.
 119                 _ => bug!("array type coerced to something other than array or slice"),
 120             };
 121             cx.struct_span_lint(ARRAY_INTO_ITER, call.ident.span, |lint| {
 122                 let mut diag = lint.build(fluent::lint::array_into_iter);
 123                 diag.set_arg("target", target);
 124                 diag.span_suggestion(
 125                     call.ident.span,
 126                     fluent::lint::use_iter_suggestion,
 127                     "iter",
 128                     Applicability::MachineApplicable,
 129                 );
 130                 if self.for_expr_span == expr.span {
 131                     diag.span_suggestion(
 132                         receiver_arg.span.shrink_to_hi().to(expr.span.shrink_to_hi()),
 133                         fluent::lint::remove_into_iter_suggestion,
 134                         "",
 135                         Applicability::MaybeIncorrect,
 136                     );
 137                 } else if receiver_ty.is_array() {
 138                     diag.multipart_suggestion(
 139                         fluent::lint::use_explicit_into_iter_suggestion,
 140                         vec![
 141                             (expr.span.shrink_to_lo(), "IntoIterator::into_iter(".into()),
 142                             (
 143                                 receiver_arg.span.shrink_to_hi().to(expr.span.shrink_to_hi()),
 144                                 ")".into(),
 145                             ),
 146                         ],
 147                         Applicability::MaybeIncorrect,
 148                     );
 149                 }
 150                 diag.emit();
 151             })
 152         }
 153     }
 154 }