Rustup to ~2016-05-28

mcarton · mcarton · commit 3b6605b4fa9c · 2016-05-27T16:44:34.000+02:00
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
@@ -187,7 +187,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
         match pat.node {
             PatKind::Box(ref pat) |
             PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
-            PatKind::TupleStruct(_, Some(ref pats)) => {
+            PatKind::TupleStruct(_, ref pats, _) => {
                 for pat in pats {
                     bindings_impl(cx, pat, map);
                 }
@@ -205,7 +205,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                     bindings_impl(cx, &pat.node.pat, map);
                 }
             }
-            PatKind::Tup(ref fields) => {
+            PatKind::Tuple(ref fields, _) => {
                 for pat in fields {
                     bindings_impl(cx, pat, map);
                 }
@@ -221,7 +221,6 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                     bindings_impl(cx, pat, map);
                 }
             }
-            PatKind::TupleStruct(..) |
             PatKind::Lit(..) |
             PatKind::QPath(..) |
             PatKind::Range(..) |
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
@@ -101,7 +101,7 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool {
         let ExprMatch(_, ref arms, _) = expr.node,
         arms.len() == 1,
         arms[0].pats.len() == 1,
-        let PatKind::Tup(ref pat) = arms[0].pats[0].node,
+        let PatKind::Tuple(ref pat, None) = arms[0].pats[0].node,
         pat.len() == 1,
         let ExprVec(ref exprs) = arms[0].body.node,
         exprs.len() == 1,
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -280,7 +280,7 @@ impl LateLintPass for LoopsPass {
         }
         if let ExprMatch(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.node {
             let pat = &arms[0].pats[0].node;
-            if let (&PatKind::TupleStruct(ref path, Some(ref pat_args)),
+            if let (&PatKind::TupleStruct(ref path, ref pat_args, _),
                     &ExprMethodCall(method_name, _, ref method_args)) = (pat, &match_expr.node) {
                 let iter_expr = &method_args[0];
                 if let Some(lhs_constructor) = path.segments.last() {
@@ -575,7 +575,7 @@ fn check_for_loop_explicit_counter(cx: &LateContext, arg: &Expr, body: &Expr, ex
 
 /// Check for the `FOR_KV_MAP` lint.
 fn check_for_loop_over_map_kv(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) {
-    if let PatKind::Tup(ref pat) = pat.node {
+    if let PatKind::Tuple(ref pat, _) = pat.node {
         if pat.len() == 2 {
             let (pat_span, kind) = match (&pat[0].node, &pat[1].node) {
                 (key, _) if pat_is_wild(key, body) => (&pat[1].span, "values"),
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
@@ -193,14 +193,13 @@ fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr:
                        (&paths::RESULT, "Ok")];
 
     let path = match arms[1].pats[0].node {
-        PatKind::TupleStruct(ref path, Some(ref inner)) => {
+        PatKind::TupleStruct(ref path, ref inner, _) => {
             // contains any non wildcard patterns? e.g. Err(err)
             if inner.iter().any(|pat| pat.node != PatKind::Wild) {
                 return;
             }
             path.to_string()
         }
-        PatKind::TupleStruct(ref path, None) => path.to_string(),
         PatKind::Ident(BindByValue(MutImmutable), ident, None) => ident.node.to_string(),
         _ => return,
     };
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
@@ -161,7 +161,7 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind
                 }
             }
         }
-        PatKind::Tup(ref inner) => {
+        PatKind::Tuple(ref inner, _) => {
             if let Some(ref init_tup) = *init {
                 if let ExprTup(ref tup) = init_tup.node {
                     for (i, p) in inner.iter().enumerate() {
diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs
@@ -68,7 +68,7 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor {
                 self.labels.remove(&label.node.as_str());
             }
             hir::ExprLoop(_, Some(label)) | hir::ExprWhile(_, _, Some(label)) => {
-                self.labels.insert(label.as_str(), expr.span);
+                self.labels.insert(label.node.as_str(), expr.span);
             }
             _ => (),
         }
diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs
@@ -95,7 +95,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             }
             (&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node,
             (&ExprLoop(ref lb, ref ll), &ExprLoop(ref rb, ref rl)) => {
-                self.eq_block(lb, rb) && both(ll, rl, |l, r| l.as_str() == r.as_str())
+                self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str())
             }
             (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => {
                 ls == rs && self.eq_expr(le, re) &&
@@ -124,7 +124,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             (&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
             (&ExprVec(ref l), &ExprVec(ref r)) => self.eq_exprs(l, r),
             (&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => {
-                self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.as_str() == r.as_str())
+                self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str())
             }
             _ => false,
         }
@@ -142,8 +142,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
     pub fn eq_pat(&self, left: &Pat, right: &Pat) -> bool {
         match (&left.node, &right.node) {
             (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
-            (&PatKind::TupleStruct(ref lp, ref la), &PatKind::TupleStruct(ref rp, ref ra)) => {
-                self.eq_path(lp, rp) && both(la, ra, |l, r| over(l, r, |l, r| self.eq_pat(l, r)))
+            (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
+                self.eq_path(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
             }
             (&PatKind::Ident(ref lb, ref li, ref lp), &PatKind::Ident(ref rb, ref ri, ref rp)) => {
                 lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
@@ -152,7 +152,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             (&PatKind::QPath(ref ls, ref lp), &PatKind::QPath(ref rs, ref rp)) => {
                 self.eq_qself(ls, rs) && self.eq_path(lp, rp)
             }
-            (&PatKind::Tup(ref l), &PatKind::Tup(ref r)) => over(l, r, |l, r| self.eq_pat(l, r)),
+            (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => ls == rs && over(l, r, |l, r| self.eq_pat(l, r)),
             (&PatKind::Range(ref ls, ref le), &PatKind::Range(ref rs, ref re)) => {
                 self.eq_expr(ls, rs) && self.eq_expr(le, re)
             }
@@ -374,7 +374,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 c.hash(&mut self.s);
                 self.hash_block(b);
                 if let Some(i) = *i {
-                    self.hash_name(&i);
+                    self.hash_name(&i.node);
                 }
             }
             ExprMatch(ref e, ref arms, ref s) => {
@@ -468,7 +468,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 self.hash_expr(cond);
                 self.hash_block(b);
                 if let Some(l) = l {
-                    self.hash_name(&l);
+                    self.hash_name(&l.node);
                 }
             }
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
@@ -828,7 +828,7 @@ pub fn recover_for_loop(expr: &Expr) -> Option<(&Pat, &Expr, &Expr)> {
             let Some(ref loopexpr) = block.expr,
             let ExprMatch(_, ref innerarms, MatchSource::ForLoopDesugar) = loopexpr.node,
             innerarms.len() == 2 && innerarms[0].pats.len() == 1,
-            let PatKind::TupleStruct(_, Some(ref somepats)) = innerarms[0].pats[0].node,
+            let PatKind::TupleStruct(_, ref somepats, _) = innerarms[0].pats[0].node,
             somepats.len() == 1
         ], {
             return Some((&somepats[0],
diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs
@@ -1,4 +1,5 @@
 #![feature(plugin, inclusive_range_syntax)]
+#![feature(dotdot_in_tuple_patterns)]
 #![plugin(clippy)]
 
 #![allow(dead_code, no_effect, unnecessary_operation)]
@@ -129,6 +130,34 @@ fn if_same_then_else() -> Result<&'static str, ()> {
         if let Some(a) = Some(42) {}
     }
 
+    if true {
+        if let (1, .., 3) = (1, 2, 3) {}
+    }
+    else { //~ERROR this `if` has identical blocks
+        if let (1, .., 3) = (1, 2, 3) {}
+    }
+
+    if true {
+        if let (1, .., 3) = (1, 2, 3) {}
+    }
+    else {
+        if let (.., 3) = (1, 2, 3) {}
+    }
+
+    if true {
+        if let (1, .., 3) = (1, 2, 3) {}
+    }
+    else {
+        if let (.., 4) = (1, 2, 3) {}
+    }
+
+    if true {
+        if let (1, .., 3) = (1, 2, 3) {}
+    }
+    else {
+        if let (.., 1, 3) = (1, 2, 3) {}
+    }
+
     if true {
         if let Some(a) = Some(42) {}
     }
@@ -165,6 +194,18 @@ fn if_same_then_else() -> Result<&'static str, ()> {
         _ => (),
     }
 
+    match (Some(42), Some(42)) {
+        (Some(a), ..) => bar(a),
+        (.., Some(a)) => bar(a), //~ERROR this `match` has identical arm bodies
+        _ => (),
+    }
+
+    match (1, 2, 3) {
+        (1, .., 3) => 42,
+        (.., 3) => 42, //~ERROR this `match` has identical arm bodies
+        _ => 0,
+    };
+
     match (Some(42), Some("")) {
         (Some(a), None) => bar(a),
         (None, Some(a)) => bar(a), // bindings have different types

Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned`
`187`	`187`	`match pat.node {`
`188`	`188`	`PatKind::Box(ref pat) \|`
`189`	`189`	`PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),`
`190`		`- PatKind::TupleStruct(_, Some(ref pats)) => {`
	`190`	`+ PatKind::TupleStruct(_, ref pats, _) => {`
`191`	`191`	`for pat in pats {`
`192`	`192`	`bindings_impl(cx, pat, map);`
`193`	`193`	`}`
`@@ -205,7 +205,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned`
`205`	`205`	`bindings_impl(cx, &pat.node.pat, map);`
`206`	`206`	`}`
`207`	`207`	`}`
`208`		`- PatKind::Tup(ref fields) => {`
	`208`	`+ PatKind::Tuple(ref fields, _) => {`
`209`	`209`	`for pat in fields {`
`210`	`210`	`bindings_impl(cx, pat, map);`
`211`	`211`	`}`
`@@ -221,7 +221,6 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned`
`221`	`221`	`bindings_impl(cx, pat, map);`
`222`	`222`	`}`
`223`	`223`	`}`
`224`		`- PatKind::TupleStruct(..) \|`
`225`	`224`	`PatKind::Lit(..) \|`
`226`	`225`	`PatKind::QPath(..) \|`
`227`	`226`	`PatKind::Range(..) \|`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`}`
`164`		`- PatKind::Tup(ref inner) => {`
	`164`	`+ PatKind::Tuple(ref inner, _) => {`
`165`	`165`	`if let Some(ref init_tup) = *init {`
`166`	`166`	`if let ExprTup(ref tup) = init_tup.node {`
`167`	`167`	`for (i, p) in inner.iter().enumerate() {`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor {`
`68`	`68`	`self.labels.remove(&label.node.as_str());`
`69`	`69`	`}`
`70`	`70`	`hir::ExprLoop(_, Some(label)) \| hir::ExprWhile(_, _, Some(label)) => {`
`71`		`- self.labels.insert(label.as_str(), expr.span);`
	`71`	`+ self.labels.insert(label.node.as_str(), expr.span);`
`72`	`72`	`}`
`73`	`73`	`_ => (),`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {`
`95`	`95`	`}`
`96`	`96`	`(&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node,`
`97`	`97`	`(&ExprLoop(ref lb, ref ll), &ExprLoop(ref rb, ref rl)) => {`
`98`		`- self.eq_block(lb, rb) && both(ll, rl, \|l, r\| l.as_str() == r.as_str())`
	`98`	`+ self.eq_block(lb, rb) && both(ll, rl, \|l, r\| l.node.as_str() == r.node.as_str())`
`99`	`99`	`}`
`100`	`100`	`(&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => {`
`101`	`101`	`ls == rs && self.eq_expr(le, re) &&`
`@@ -124,7 +124,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {`
`124`	`124`	`(&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),`
`125`	`125`	`(&ExprVec(ref l), &ExprVec(ref r)) => self.eq_exprs(l, r),`
`126`	`126`	`(&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => {`
`127`		`- self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, \|l, r\| l.as_str() == r.as_str())`
	`127`	`+ self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, \|l, r\| l.node.as_str() == r.node.as_str())`
`128`	`128`	`}`
`129`	`129`	`_ => false,`
`130`	`130`	`}`
`@@ -142,8 +142,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {`
`142`	`142`	`pub fn eq_pat(&self, left: &Pat, right: &Pat) -> bool {`
`143`	`143`	`match (&left.node, &right.node) {`
`144`	`144`	`(&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),`
`145`		`- (&PatKind::TupleStruct(ref lp, ref la), &PatKind::TupleStruct(ref rp, ref ra)) => {`
`146`		`- self.eq_path(lp, rp) && both(la, ra, \|l, r\| over(l, r, \|l, r\| self.eq_pat(l, r)))`
	`145`	`+ (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {`
	`146`	`+ self.eq_path(lp, rp) && over(la, ra, \|l, r\| self.eq_pat(l, r)) && ls == rs`
`147`	`147`	`}`
`148`	`148`	`(&PatKind::Ident(ref lb, ref li, ref lp), &PatKind::Ident(ref rb, ref ri, ref rp)) => {`
`149`	`149`	`lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, \|l, r\| self.eq_pat(l, r))`
`@@ -152,7 +152,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {`
`152`	`152`	`(&PatKind::QPath(ref ls, ref lp), &PatKind::QPath(ref rs, ref rp)) => {`
`153`	`153`	`self.eq_qself(ls, rs) && self.eq_path(lp, rp)`
`154`	`154`	`}`
`155`		`- (&PatKind::Tup(ref l), &PatKind::Tup(ref r)) => over(l, r, \|l, r\| self.eq_pat(l, r)),`
	`155`	`+ (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => ls == rs && over(l, r, \|l, r\| self.eq_pat(l, r)),`
`156`	`156`	`(&PatKind::Range(ref ls, ref le), &PatKind::Range(ref rs, ref re)) => {`
`157`	`157`	`self.eq_expr(ls, rs) && self.eq_expr(le, re)`
`158`	`158`	`}`
`@@ -374,7 +374,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {`
`374`	`374`	`c.hash(&mut self.s);`
`375`	`375`	`self.hash_block(b);`
`376`	`376`	`if let Some(i) = *i {`
`377`		`- self.hash_name(&i);`
	`377`	`+ self.hash_name(&i.node);`
`378`	`378`	`}`
`379`	`379`	`}`
`380`	`380`	`ExprMatch(ref e, ref arms, ref s) => {`
`@@ -468,7 +468,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {`
`468`	`468`	`self.hash_expr(cond);`
`469`	`469`	`self.hash_block(b);`
`470`	`470`	`if let Some(l) = l {`
`471`		`- self.hash_name(&l);`
	`471`	`+ self.hash_name(&l.node);`
`472`	`472`	`}`
`473`	`473`	`}`
`474`	`474`	`}`