From 2f13c3bdefefb7947049ed51edde8db341994164 Mon Sep 17 00:00:00 2001
From: mcarton <cartonmartin+git@gmail.com>
Date: Fri, 11 Mar 2016 22:10:40 +0100
Subject: [PATCH] Small nits on INDEXING_SLICING

---
 src/array_indexing.rs                | 28 ++++++++++------------------
 src/lib.rs                           |  2 +-
 tests/compile-fail/array_indexing.rs | 15 +++++----------
 3 files changed, 16 insertions(+), 29 deletions(-)

diff --git a/src/array_indexing.rs b/src/array_indexing.rs
index abce04f0b77..274491b7c96 100644
--- a/src/array_indexing.rs
+++ b/src/array_indexing.rs
@@ -69,34 +69,26 @@ fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
                 if let Ok(ConstVal::Uint(const_index)) = const_index {
                     if size <= const_index {
                         utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds");
-                        utils::span_lint(cx, INDEXING_SLICING, e.span, "indexing may panic");
-                    } else {
-                        // Index is within bounds
-                        return;
                     }
+
+                    return;
                 }
 
                 // Index is a constant range
                 if let Some(range) = utils::unsugar_range(index) {
                     let start = range.start.map(|start|
-                        eval_const_expr_partial(cx.tcx, start, ExprTypeChecked, None));
+                        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));
+                        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 start >= size || end >= size {
                             utils::span_lint(cx,
                                              OUT_OF_BOUNDS_INDEXING,
                                              e.span,
                                              "range is out of bounds");
-                            utils::span_lint(cx,
-                                             INDEXING_SLICING,
-                                             e.span,
-                                             "slicing may panic");
-                        } else {
-                            // Range is within bounds
-                            return;
                         }
+                        return;
                     }
                 }
             }
@@ -120,19 +112,19 @@ fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
 ///
 /// Note: we assume the start and the end of the range are unsigned, since array slicing
 /// works only on usize
-fn to_const_range<T>(start: Option<Result<ConstVal, T>>,
-                    end: Option<Result<ConstVal, T>>,
+fn to_const_range(start: Option<Option<ConstVal>>,
+                    end: Option<Option<ConstVal>>,
                     limits: RangeLimits,
                     array_size: u64)
                     -> Option<(u64, u64)> {
     let start = match start {
-        Some(Ok(ConstVal::Uint(x))) => x,
+        Some(Some(ConstVal::Uint(x))) => x,
         Some(_) => return None,
         None => 0,
     };
 
     let end = match end {
-        Some(Ok(ConstVal::Uint(x))) => {
+        Some(Some(ConstVal::Uint(x))) => {
             if limits == RangeLimits::Closed {
                 x
             } else {
diff --git a/src/lib.rs b/src/lib.rs
index 664819b97ec..4b9d5d8c9c4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,7 @@
 #![feature(rustc_private, collections)]
 #![feature(iter_arith)]
 #![feature(custom_attribute)]
-#![allow(unknown_lints)]
+#![allow(indexing_slicing, shadow_reuse, unknown_lints)]
 
 // this only exists to allow the "dogfood" integration test to work
 #[allow(dead_code)]
diff --git a/tests/compile-fail/array_indexing.rs b/tests/compile-fail/array_indexing.rs
index bcd25f5bf06..14f3448a9f6 100644
--- a/tests/compile-fail/array_indexing.rs
+++ b/tests/compile-fail/array_indexing.rs
@@ -9,20 +9,15 @@ fn main() {
     let x = [1,2,3,4];
     x[0];
     x[3];
-    x[4]; //~ERROR: indexing may panic
-          //~^ ERROR: const index is out of bounds
-    x[1 << 3]; //~ERROR: indexing may panic
-               //~^ ERROR: const index is out of bounds
-    &x[1..5]; //~ERROR: slicing may panic
-              //~^ ERROR: range is out of bounds
+    x[4]; //~ERROR: const index is out of bounds
+    x[1 << 3]; //~ERROR: const index is out of bounds
+    &x[1..5]; //~ERROR: range is out of bounds
     &x[0..3];
-    &x[0...4]; //~ERROR: slicing may panic
-               //~^ ERROR: range is out of bounds
+    &x[0...4]; //~ERROR: range is out of bounds
     &x[..];
     &x[1..];
     &x[..4];
-    &x[..5]; //~ERROR: slicing may panic
-             //~^ ERROR: range is out of bounds
+    &x[..5]; //~ERROR: range is out of bounds
 
     let y = &x;
     y[0]; //~ERROR: indexing may panic
-- 
2.44.0