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