Rustup

Author: mcarton

clippy_lints/src/array_indexing.rs

@@ -1,10 +1,10 @@
 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::{self, higher};
 
@@ -56,11 +56,11 @@ impl LintPass for ArrayIndexing {
 }
 
 impl LateLintPass for ArrayIndexing {
-    fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
-        if let ExprIndex(ref array, ref index) = e.node {
+    fn check_expr(&mut self, cx: &LateContext, e: &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 {
+            if let ty::TyArray(_, size) = ty.sty {
                 let size = ConstInt::Infer(size as u64);
 
                 // Index is a constant uint

clippy_lints/src/consts.rs

@@ -268,7 +268,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
             ExprBlock(ref block) => self.block(block),
             ExprIf(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, otherwise),
             ExprLit(ref lit) => Some(lit_to_constant(&lit.node)),
-            ExprVec(ref vec) => self.multi(vec).map(Constant::Vec),
+            ExprArray(ref vec) => self.multi(vec).map(Constant::Vec),
             ExprTup(ref tup) => self.multi(tup).map(Constant::Tuple),
             ExprRepeat(ref value, ref number) => {
                 self.binop_apply(value, number, |v, n| Some(Constant::Repeat(Box::new(v), n.as_u64() as usize)))

clippy_lints/src/copies.rs

@@ -265,7 +265,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                     bindings_impl(cx, pat, map);
                 }
             }
-            PatKind::Vec(ref lhs, ref mid, ref rhs) => {
+            PatKind::Slice(ref lhs, ref mid, ref rhs) => {
                 for pat in lhs {
                     bindings_impl(cx, pat, map);
                 }

clippy_lints/src/eval_order_dependence.rs

@@ -213,7 +213,7 @@ fn check_expr<'v, 't>(vis: & mut ReadVisitor<'v, 't>, expr: &'v Expr) -> StopEar
     }
 
     match expr.node {
-        ExprVec(_) |
+        ExprArray(_) |
         ExprTup(_) |
         ExprMethodCall(_, _, _) |
         ExprCall(_, _) |

clippy_lints/src/format.rs

@@ -82,7 +82,7 @@ pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Exp
         decl.name.as_str() == "__STATIC_FMTSTR",
         let ItemStatic(_, _, ref expr) = decl.node,
         let ExprAddrOf(_, ref expr) = expr.node, // &[""]
-        let ExprVec(ref exprs) = expr.node,
+        let ExprArray(ref exprs) = expr.node,
     ], {
         let mut result = Vec::new();
         for expr in exprs {
@@ -123,7 +123,7 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool {
         arms[0].pats.len() == 1,
         let PatKind::Tuple(ref pat, None) = arms[0].pats[0].node,
         pat.len() == 1,
-        let ExprVec(ref exprs) = arms[0].body.node,
+        let ExprArray(ref exprs) = arms[0].body.node,
         exprs.len() == 1,
         let ExprCall(_, ref args) = exprs[0].node,
         args.len() == 2,

clippy_lints/src/no_effect.rs

@@ -50,7 +50,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool {
         Expr_::ExprPath(..) => true,
         Expr_::ExprIndex(ref a, ref b) |
         Expr_::ExprBinary(_, ref a, ref b) => has_no_effect(cx, a) && has_no_effect(cx, b),
-        Expr_::ExprVec(ref v) |
+        Expr_::ExprArray(ref v) |
         Expr_::ExprTup(ref v) => v.iter().all(|val| has_no_effect(cx, val)),
         Expr_::ExprRepeat(ref inner, _) |
         Expr_::ExprCast(ref inner, _) |
@@ -130,7 +130,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option<Vec<&'a Exp
     match expr.node {
         Expr_::ExprIndex(ref a, ref b) |
         Expr_::ExprBinary(_, ref a, ref b) => Some(vec![&**a, &**b]),
-        Expr_::ExprVec(ref v) |
+        Expr_::ExprArray(ref v) |
         Expr_::ExprTup(ref v) => Some(v.iter().map(Deref::deref).collect()),
         Expr_::ExprRepeat(ref inner, _) |
         Expr_::ExprCast(ref inner, _) |

clippy_lints/src/regex.rs

@@ -190,7 +190,7 @@ fn is_trivial_regex(s: &regex_syntax::Expr) -> Option<&'static str> {
 fn check_set(cx: &LateContext, expr: &Expr, utf8: bool) {
     if_let_chain! {[
         let ExprAddrOf(_, ref expr) = expr.node,
-        let ExprVec(ref exprs) = expr.node,
+        let ExprArray(ref exprs) = expr.node,
     ], {
         for expr in exprs {
             check_regex(cx, expr, utf8);

clippy_lints/src/shadow.rs

@@ -281,7 +281,7 @@ fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) {
         ExprLoop(ref block, _) => check_block(cx, block, bindings),
         // ExprCall
         // ExprMethodCall
-        ExprVec(ref v) | ExprTup(ref v) => {
+        ExprArray(ref v) | ExprTup(ref v) => {
             for e in v {
                 check_expr(cx, e, bindings)
             }
@@ -319,8 +319,8 @@ fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) {
 fn check_ty(cx: &LateContext, ty: &Ty, bindings: &mut Vec<(Name, Span)>) {
     match ty.node {
         TyObjectSum(ref sty, _) |
-        TyVec(ref sty) => check_ty(cx, sty, bindings),
-        TyFixedLengthVec(ref fty, ref expr) => {
+        TySlice(ref sty) => check_ty(cx, sty, bindings),
+        TyArray(ref fty, ref expr) => {
             check_ty(cx, fty, bindings);
             check_expr(cx, expr, bindings);
         }

clippy_lints/src/types.rs

@@ -627,9 +627,9 @@ impl<'v> Visitor<'v> for TypeComplexityVisitor {
 
             // the "normal" components of a type: named types, arrays/tuples
             TyPath(..) |
-            TyVec(..) |
+            TySlice(..) |
             TyTup(..) |
-            TyFixedLengthVec(..) => (10 * self.nest, 1),
+            TyArray(..) => (10 * self.nest, 1),
 
             // "Sum" of trait bounds
             TyObjectSum(..) => (20 * self.nest, 0),

clippy_lints/src/utils/higher.rs

@@ -180,7 +180,7 @@ pub fn vec_macro<'e>(cx: &LateContext, expr: &'e hir::Expr) -> Option<VecArgs<'e
             // `vec![a, b, c]` case
             if_let_chain!{[
                 let hir::ExprBox(ref boxed) = args[0].node,
-                let hir::ExprVec(ref args) = boxed.node
+                let hir::ExprArray(ref args) = boxed.node
             ], {
                 return Some(VecArgs::Vec(&*args));
             }}