update to the rust-PR that unblocks clippy

[rust.git] / clippy_lints / src / array_indexing.rs

diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs
index f3b7297b2969326938e7ecf64e00b20f26fec603..399f93d08c7cd419641f715efa4e534db03fe83b 100644 (file)
--- a/clippy_lints/src/array_indexing.rs
+++ b/clippy_lints/src/array_indexing.rs
@@ -1,22 +1,21 @@
 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];
@@ -25,27 +24,25 @@
 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"
 }
 
@@ -58,12 +55,12 @@ fn get_lints(&self) -> LintArray {
     }
 }
 
-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
@@ -77,7 +74,7 @@ fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
                 }
 
                 // 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());
@@ -94,7 +91,7 @@ fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
                 }
             }
 
-            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;