]>
Commit | Line | Data |
---|---|---|
ea8adc8c XL |
1 | use rustc::lint::*; |
2 | use rustc::middle::const_val::ConstVal; | |
3 | use rustc::ty; | |
4 | use rustc::ty::subst::Substs; | |
5 | use rustc_const_eval::ConstContext; | |
abe05a73 | 6 | use rustc_const_math::{ConstInt, ConstIsize, ConstUsize}; |
ea8adc8c XL |
7 | use rustc::hir; |
8 | use syntax::ast::RangeLimits; | |
9 | use utils::{self, higher}; | |
abe05a73 | 10 | use utils::const_to_u64; |
ea8adc8c XL |
11 | |
12 | /// **What it does:** Checks for out of bounds array indexing with a constant | |
13 | /// index. | |
14 | /// | |
15 | /// **Why is this bad?** This will always panic at runtime. | |
16 | /// | |
17 | /// **Known problems:** Hopefully none. | |
18 | /// | |
19 | /// **Example:** | |
20 | /// ```rust | |
21 | /// let x = [1,2,3,4]; | |
22 | /// ... | |
23 | /// x[9]; | |
24 | /// &x[2..9]; | |
25 | /// ``` | |
26 | declare_lint! { | |
27 | pub OUT_OF_BOUNDS_INDEXING, | |
28 | Deny, | |
29 | "out of bounds constant indexing" | |
30 | } | |
31 | ||
32 | /// **What it does:** Checks for usage of indexing or slicing. | |
33 | /// | |
34 | /// **Why is this bad?** Usually, this can be safely allowed. However, in some | |
35 | /// domains such as kernel development, a panic can cause the whole operating | |
36 | /// system to crash. | |
37 | /// | |
38 | /// **Known problems:** Hopefully none. | |
39 | /// | |
40 | /// **Example:** | |
41 | /// ```rust | |
42 | /// ... | |
43 | /// x[2]; | |
44 | /// &x[0..2]; | |
45 | /// ``` | |
46 | declare_restriction_lint! { | |
47 | pub INDEXING_SLICING, | |
48 | "indexing/slicing usage" | |
49 | } | |
50 | ||
51 | #[derive(Copy, Clone)] | |
52 | pub struct ArrayIndexing; | |
53 | ||
54 | impl LintPass for ArrayIndexing { | |
55 | fn get_lints(&self) -> LintArray { | |
56 | lint_array!(INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING) | |
57 | } | |
58 | } | |
59 | ||
60 | impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing { | |
61 | fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { | |
62 | if let hir::ExprIndex(ref array, ref index) = e.node { | |
63 | // Array with known size can be checked statically | |
64 | let ty = cx.tables.expr_ty(array); | |
65 | if let ty::TyArray(_, size) = ty.sty { | |
66 | let size = ConstInt::Usize( | |
abe05a73 | 67 | ConstUsize::new(const_to_u64(size), cx.sess().target.usize_ty).expect("array size is invalid"), |
ea8adc8c XL |
68 | ); |
69 | let parent_item = cx.tcx.hir.get_parent(e.id); | |
70 | let parent_def_id = cx.tcx.hir.local_def_id(parent_item); | |
71 | let substs = Substs::identity_for_item(cx.tcx, parent_def_id); | |
72 | let constcx = ConstContext::new(cx.tcx, cx.param_env.and(substs), cx.tables); | |
73 | ||
74 | // Index is a constant uint | |
abe05a73 XL |
75 | if let Ok(const_index) = constcx.eval(index) { |
76 | if let ConstVal::Integral(const_index) = const_index.val { | |
77 | if size <= const_index { | |
78 | utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds"); | |
79 | } | |
ea8adc8c | 80 | |
abe05a73 XL |
81 | return; |
82 | } | |
ea8adc8c XL |
83 | } |
84 | ||
85 | // Index is a constant range | |
86 | if let Some(range) = higher::range(index) { | |
87 | let start = range.start.map(|start| constcx.eval(start)).map(|v| v.ok()); | |
88 | let end = range.end.map(|end| constcx.eval(end)).map(|v| v.ok()); | |
89 | ||
90 | if let Some((start, end)) = to_const_range(&start, &end, range.limits, size) { | |
91 | if start > size || end > size { | |
92 | utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "range is out of bounds"); | |
93 | } | |
94 | return; | |
95 | } | |
96 | } | |
97 | } | |
98 | ||
99 | if let Some(range) = higher::range(index) { | |
100 | // Full ranges are always valid | |
101 | if range.start.is_none() && range.end.is_none() { | |
102 | return; | |
103 | } | |
104 | ||
105 | // Impossible to know if indexing or slicing is correct | |
106 | utils::span_lint(cx, INDEXING_SLICING, e.span, "slicing may panic"); | |
107 | } else { | |
108 | utils::span_lint(cx, INDEXING_SLICING, e.span, "indexing may panic"); | |
109 | } | |
110 | } | |
111 | } | |
112 | } | |
113 | ||
114 | /// Returns an option containing a tuple with the start and end (exclusive) of | |
115 | /// the range. | |
116 | fn to_const_range( | |
abe05a73 XL |
117 | start: &Option<Option<&ty::Const>>, |
118 | end: &Option<Option<&ty::Const>>, | |
ea8adc8c XL |
119 | limits: RangeLimits, |
120 | array_size: ConstInt, | |
121 | ) -> Option<(ConstInt, ConstInt)> { | |
122 | let start = match *start { | |
abe05a73 XL |
123 | Some(Some(&ty::Const { |
124 | val: ConstVal::Integral(x), | |
125 | .. | |
126 | })) => x, | |
ea8adc8c XL |
127 | Some(_) => return None, |
128 | None => ConstInt::U8(0), | |
129 | }; | |
130 | ||
131 | let end = match *end { | |
abe05a73 XL |
132 | Some(Some(&ty::Const { |
133 | val: ConstVal::Integral(x), | |
134 | .. | |
135 | })) => if limits == RangeLimits::Closed { | |
136 | match x { | |
137 | ConstInt::U8(_) => (x + ConstInt::U8(1)), | |
138 | ConstInt::U16(_) => (x + ConstInt::U16(1)), | |
139 | ConstInt::U32(_) => (x + ConstInt::U32(1)), | |
140 | ConstInt::U64(_) => (x + ConstInt::U64(1)), | |
141 | ConstInt::U128(_) => (x + ConstInt::U128(1)), | |
142 | ConstInt::Usize(ConstUsize::Us16(_)) => (x + ConstInt::Usize(ConstUsize::Us16(1))), | |
143 | ConstInt::Usize(ConstUsize::Us32(_)) => (x + ConstInt::Usize(ConstUsize::Us32(1))), | |
144 | ConstInt::Usize(ConstUsize::Us64(_)) => (x + ConstInt::Usize(ConstUsize::Us64(1))), | |
145 | ConstInt::I8(_) => (x + ConstInt::I8(1)), | |
146 | ConstInt::I16(_) => (x + ConstInt::I16(1)), | |
147 | ConstInt::I32(_) => (x + ConstInt::I32(1)), | |
148 | ConstInt::I64(_) => (x + ConstInt::I64(1)), | |
149 | ConstInt::I128(_) => (x + ConstInt::I128(1)), | |
150 | ConstInt::Isize(ConstIsize::Is16(_)) => (x + ConstInt::Isize(ConstIsize::Is16(1))), | |
151 | ConstInt::Isize(ConstIsize::Is32(_)) => (x + ConstInt::Isize(ConstIsize::Is32(1))), | |
152 | ConstInt::Isize(ConstIsize::Is64(_)) => (x + ConstInt::Isize(ConstIsize::Is64(1))), | |
153 | }.expect("such a big array is not realistic") | |
154 | } else { | |
155 | x | |
ea8adc8c XL |
156 | }, |
157 | Some(_) => return None, | |
158 | None => array_size, | |
159 | }; | |
160 | ||
161 | Some((start, end)) | |
162 | } |