use rustc::lint::*;
use rustc::middle::const_val::ConstVal;
-use rustc::ty::TyArray;
+use rustc::ty;
use rustc_const_eval::EvalHint::ExprTypeChecked;
use rustc_const_eval::eval_const_expr_partial;
use rustc_const_math::ConstInt;
-use rustc::hir::*;
+use rustc::hir;
use syntax::ast::RangeLimits;
-use utils;
+use utils::{self, higher};
-/// **What it does:** Check for out of bounds array indexing with a constant index.
+/// **What it does:** Checks for out of bounds array indexing with a constant index.
///
/// **Why is this bad?** This will always panic at runtime.
///
/// **Known problems:** Hopefully none.
///
/// **Example:**
-///
-/// ```
+/// ```rust
/// let x = [1,2,3,4];
/// ...
/// x[9];
declare_lint! {
pub OUT_OF_BOUNDS_INDEXING,
Deny,
- "out of bound constant indexing"
+ "out of bounds constant indexing"
}
-/// **What it does:** Check for usage of indexing or slicing.
+/// **What it does:** Checks for usage of indexing or slicing.
///
-/// **Why is this bad?** Usually, this can be safely allowed. However,
-/// in some domains such as kernel development, a panic can cause the
-/// whole operating system to crash.
+/// **Why is this bad?** Usually, this can be safely allowed. However, in some
+/// domains such as kernel development, a panic can cause the whole operating
+/// system to crash.
///
/// **Known problems:** Hopefully none.
///
/// **Example:**
-///
-/// ```
+/// ```rust
/// ...
/// x[2];
/// &x[0..2];
/// ```
-declare_lint! {
+declare_restriction_lint! {
pub INDEXING_SLICING,
- Allow,
"indexing/slicing usage"
}
}
}
-impl LateLintPass for ArrayIndexing {
- fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
- if let ExprIndex(ref array, ref index) = e.node {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) {
+ if let hir::ExprIndex(ref array, ref index) = e.node {
// Array with known size can be checked statically
- let ty = cx.tcx.expr_ty(array);
- if let TyArray(_, size) = ty.sty {
+ let ty = cx.tcx.tables().expr_ty(array);
+ if let ty::TyArray(_, size) = ty.sty {
let size = ConstInt::Infer(size as u64);
// Index is a constant uint
}
// Index is a constant range
- if let Some(range) = utils::unsugar_range(index) {
+ if let Some(range) = higher::range(index) {
let start = range.start
- .map(|start| eval_const_expr_partial(cx.tcx, start, ExprTypeChecked, None))
- .map(|v| v.ok());
+ .map(|start| eval_const_expr_partial(cx.tcx, start, ExprTypeChecked, None))
+ .map(|v| v.ok());
let end = range.end
- .map(|end| eval_const_expr_partial(cx.tcx, end, ExprTypeChecked, None))
- .map(|v| v.ok());
+ .map(|end| eval_const_expr_partial(cx.tcx, end, ExprTypeChecked, None))
+ .map(|v| v.ok());
if let Some((start, end)) = to_const_range(start, end, range.limits, size) {
if start > size || end > size {
}
}
- if let Some(range) = utils::unsugar_range(index) {
+ if let Some(range) = higher::range(index) {
// Full ranges are always valid
if range.start.is_none() && range.end.is_none() {
return;