Rustup

Author: oli-obk

CHANGELOG.md

@@ -1,6 +1,9 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 0.0.160
+* Update to *rustc 1.22.0-nightly (dd08c3070 2017-09-12)*
+
 ## 0.0.159
 * Update to *rustc 1.22.0-nightly (eba374fb2 2017-09-11)*
 * New lint: [`clone_on_ref_ptr`]

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.0.159"
+version = "0.0.160"
 authors = [
 	"Manish Goregaokar <[email protected]>",
 	"Andre Bogus <[email protected]>",
@@ -31,7 +31,7 @@ path = "src/main.rs"
 
 [dependencies]
 # begin automatic update
-clippy_lints = { version = "0.0.159", path = "clippy_lints" }
+clippy_lints = { version = "0.0.160", path = "clippy_lints" }
 # end automatic update
 cargo_metadata = "0.2"
 

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin automatic update
-version = "0.0.159"
+version = "0.0.160"
 # end automatic update
 authors = [
 	"Manish Goregaokar <[email protected]>",

clippy_lints/Cargo.toml

@@ -7,6 +7,7 @@ use rustc_const_math::{ConstInt, ConstIsize, ConstUsize};
 use rustc::hir;
 use syntax::ast::RangeLimits;
 use utils::{self, higher};
+use utils::const_to_u64;
 
 /// **What it does:** Checks for out of bounds array indexing with a constant
 /// index.
@@ -63,21 +64,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
             let ty = cx.tables.expr_ty(array);
             if let ty::TyArray(_, size) = ty.sty {
                 let size = ConstInt::Usize(
-                    ConstUsize::new(size as u64, cx.sess().target.uint_type).expect("array size is invalid"),
+                    ConstUsize::new(const_to_u64(size), cx.sess().target.usize_ty).expect("array size is invalid"),
                 );
                 let parent_item = cx.tcx.hir.get_parent(e.id);
                 let parent_def_id = cx.tcx.hir.local_def_id(parent_item);
                 let substs = Substs::identity_for_item(cx.tcx, parent_def_id);
                 let constcx = ConstContext::new(cx.tcx, cx.param_env.and(substs), cx.tables);
 
                 // Index is a constant uint
-                let const_index = constcx.eval(index);
-                if let Ok(ConstVal::Integral(const_index)) = const_index {
-                    if size <= const_index {
-                        utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds");
-                    }
+                if let Ok(const_index) = constcx.eval(index) {
+                    if let ConstVal::Integral(const_index) = const_index.val {
+                        if size <= const_index {
+                            utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds");
+                        }
 
-                    return;
+                        return;
+                    }
                 }
 
                 // Index is a constant range
@@ -112,19 +114,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
 /// Returns an option containing a tuple with the start and end (exclusive) of
 /// the range.
 fn to_const_range(
-    start: &Option<Option<ConstVal>>,
-    end: &Option<Option<ConstVal>>,
+    start: &Option<Option<&ty::Const>>,
+    end: &Option<Option<&ty::Const>>,
     limits: RangeLimits,
     array_size: ConstInt,
 ) -> Option<(ConstInt, ConstInt)> {
     let start = match *start {
-        Some(Some(ConstVal::Integral(x))) => x,
+        Some(Some(&ty::Const { val: ConstVal::Integral(x), .. })) => x,
         Some(_) => return None,
         None => ConstInt::U8(0),
     };
 
     let end = match *end {
-        Some(Some(ConstVal::Integral(x))) => if limits == RangeLimits::Closed {
+        Some(Some(&ty::Const { val: ConstVal::Integral(x), .. })) => if limits == RangeLimits::Closed {
             match x {
                 ConstInt::U8(_) => (x + ConstInt::U8(1)),
                 ConstInt::U16(_) => (x + ConstInt::U16(1)),

clippy_lints/src/array_indexing.rs

@@ -14,6 +14,7 @@ use std::mem;
 use std::rc::Rc;
 use syntax::ast::{FloatTy, LitKind, StrStyle};
 use syntax::ptr::P;
+use utils::const_to_u64;
 
 #[derive(Debug, Copy, Clone)]
 pub enum FloatWidth {
@@ -49,7 +50,7 @@ pub enum Constant {
     /// an array of constants
     Vec(Vec<Constant>),
     /// also an array, but with only one constant, repeated N times
-    Repeat(Box<Constant>, usize),
+    Repeat(Box<Constant>, u64),
     /// a tuple of constants
     Tuple(Vec<Constant>),
 }
@@ -175,10 +176,10 @@ pub fn lit_to_constant<'a, 'tcx>(lit: &LitKind, tcx: TyCtxt<'a, 'tcx, 'tcx>, mut
         LitKind::Char(c) => Constant::Char(c),
         LitKind::Int(n, hint) => match (&ty.sty, hint) {
             (&ty::TyInt(ity), _) | (_, Signed(ity)) => {
-                Constant::Int(ConstInt::new_signed_truncating(n as i128, ity, tcx.sess.target.int_type))
+                Constant::Int(ConstInt::new_signed_truncating(n as i128, ity, tcx.sess.target.isize_ty))
             },
             (&ty::TyUint(uty), _) | (_, Unsigned(uty)) => {
-                Constant::Int(ConstInt::new_unsigned_truncating(n as u128, uty, tcx.sess.target.uint_type))
+                Constant::Int(ConstInt::new_unsigned_truncating(n as u128, uty, tcx.sess.target.usize_ty))
             },
             _ => bug!(),
         },
@@ -249,7 +250,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
             ExprTup(ref tup) => self.multi(tup).map(Constant::Tuple),
             ExprRepeat(ref value, _) => {
                 let n = match self.tables.expr_ty(e).sty {
-                    ty::TyArray(_, n) => n,
+                    ty::TyArray(_, n) => const_to_u64(n),
                     _ => span_bug!(e.span, "typeck error"),
                 };
                 self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))

clippy_lints/src/consts.rs

@@ -143,17 +143,8 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref
             // Some types are not Clone by default but could be cloned “by hand” if necessary
             ty::TyAdt(def, substs) => for variant in &def.variants {
                 for field in &variant.fields {
-                    match field.ty(cx.tcx, substs).sty {
-                        ty::TyArray(_, size) if size > 32 => {
-                            return;
-                        },
-                        ty::TyFnPtr(..) => {
-                            return;
-                        },
-                        ty::TyTuple(tys, _) if tys.len() > 12 => {
-                            return;
-                        },
-                        _ => (),
+                    if let ty::TyFnDef(..) = field.ty(cx.tcx, substs).sty {
+                        return;
                     }
                 }
             },

clippy_lints/src/derive.rs

@@ -55,8 +55,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant {
                         .at(expr.span)
                         .const_eval(param_env.and((did, substs)))
                     {
-                        Ok(ConstVal::Integral(Usize(Us64(i)))) => u64::from(i as u32) != i,
-                        Ok(ConstVal::Integral(Isize(Is64(i)))) => i64::from(i as i32) != i,
+                        Ok(&ty::Const { val: ConstVal::Integral(Usize(Us64(i))), .. }) => u64::from(i as u32) != i,
+                        Ok(&ty::Const { val: ConstVal::Integral(Isize(Is64(i))), .. }) => i64::from(i as i32) != i,
                         _ => false,
                     };
                     if bad {

clippy_lints/src/enum_clike.rs

@@ -8,6 +8,7 @@
 #![feature(slice_patterns)]
 #![feature(stmt_expr_attributes)]
 #![feature(conservative_impl_trait)]
+#![feature(inclusive_range_syntax, range_contains)]
 #![allow(unknown_lints, indexing_slicing, shadow_reuse, missing_docs_in_private_items)]
 
 #[macro_use]

clippy_lints/src/lib.rs

@@ -13,6 +13,7 @@ use rustc_const_eval::ConstContext;
 use std::collections::{HashMap, HashSet};
 use syntax::ast;
 use utils::sugg;
+use utils::const_to_u64;
 
 use utils::{get_enclosing_block, get_parent_expr, higher, in_external_macro, is_integer_literal, is_refutable,
             last_path_segment, match_trait_method, match_type, multispan_sugg, snippet, snippet_opt,
@@ -969,7 +970,7 @@ fn is_len_call(expr: &Expr, var: &Name) -> bool {
     false
 }
 
-fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
+fn check_for_loop_reverse_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arg: &'tcx Expr, expr: &'tcx Expr) {
     // if this for loop is iterating over a two-sided range...
     if let Some(higher::Range {
         start: Some(start),
@@ -989,7 +990,7 @@ fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
                 // who think that this will iterate from the larger value to the
                 // smaller value.
                 let (sup, eq) = match (start_idx, end_idx) {
-                    (ConstVal::Integral(start_idx), ConstVal::Integral(end_idx)) => {
+                    (&ty::Const{ val: ConstVal::Integral(start_idx), .. }, &ty::Const{ val: ConstVal::Integral(end_idx), .. }) => {
                         (start_idx > end_idx, start_idx == end_idx)
                     },
                     _ => (false, false),
@@ -1461,7 +1462,7 @@ fn is_ref_iterable_type(cx: &LateContext, e: &Expr) -> bool {
 fn is_iterable_array(ty: Ty) -> bool {
     // IntoIterator is currently only implemented for array sizes <= 32 in rustc
     match ty.sty {
-        ty::TyArray(_, 0...32) => true,
+        ty::TyArray(_, n) => (0...32).contains(const_to_u64(n)),
         _ => false,
     }
 }