Fix match_ref_pats flagged by Clippy

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 1f34af617d588e409501a8b85cb7012c00f82c4a..bc8d7333896131455f349926365d573477949627 100644 (file)
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1687,9 +1687,9 @@ pub enum Visibility {
 
 impl Visibility {
     pub fn inherit_from(&self, parent_visibility: Visibility) -> Visibility {
-        match self {
-            &Inherited => parent_visibility,
-            &Public => *self
+        match *self {
+            Inherited => parent_visibility,
+            Public => *self
         }
     }
 }

diff --git a/src/libsyntax/ext/deriving/generic/ty.rs b/src/libsyntax/ext/deriving/generic/ty.rs
index 9e8e68c0b8cce1e49c80434939b7bc42dba67984..67826c9c6cdffab502f84010bbd8119e13873a72 100644 (file)
--- a/src/libsyntax/ext/deriving/generic/ty.rs
+++ b/src/libsyntax/ext/deriving/generic/ty.rs
@@ -242,8 +242,8 @@ pub fn to_generics(&self,
             cx.lifetime_def(span, cx.ident_of(*lt).name, bounds)
         }).collect();
         let ty_params = self.bounds.iter().map(|t| {
-            match t {
-                &(ref name, ref bounds) => {
+            match *t {
+                (ref name, ref bounds) => {
                     mk_ty_param(cx,
                                 span,
                                 *name,

diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index d743a601bbb4b2f23c4cafb3bb19137daeb957ca..5e5b815818161de75828c14193a6c4511d8de809 100644 (file)
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -63,9 +63,9 @@ fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
 
     impl<T: ToTokens> ToTokens for Option<T> {
         fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
-            match self {
-                &Some(ref t) => t.to_tokens(cx),
-                &None => Vec::new(),
+            match *self {
+                Some(ref t) => t.to_tokens(cx),
+                None => Vec::new(),
             }
         }
     }

diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index dded634882dc150bb56acf65e9089016fd6f8d33..675482fd644cd24f973bb0bdfef3172c64372c91 100644 (file)
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -107,16 +107,16 @@ enum TokenTreeOrTokenTreeVec {
 
 impl TokenTreeOrTokenTreeVec {
     fn len(&self) -> usize {
-        match self {
-            &TtSeq(ref v) => v.len(),
-            &Tt(ref tt) => tt.len(),
+        match *self {
+            TtSeq(ref v) => v.len(),
+            Tt(ref tt) => tt.len(),
         }
     }
 
     fn get_tt(&self, index: usize) -> TokenTree {
-        match self {
-            &TtSeq(ref v) => v[index].clone(),
-            &Tt(ref tt) => tt.get_tt(index),
+        match *self {
+            TtSeq(ref v) => v[index].clone(),
+            Tt(ref tt) => tt.get_tt(index),
         }
     }
 }
@@ -144,17 +144,17 @@ pub struct MatcherPos {
 
 pub fn count_names(ms: &[TokenTree]) -> usize {
     ms.iter().fold(0, |count, elt| {
-        count + match elt {
-            &TokenTree::Sequence(_, ref seq) => {
+        count + match *elt {
+            TokenTree::Sequence(_, ref seq) => {
                 seq.num_captures
             }
-            &TokenTree::Delimited(_, ref delim) => {
+            TokenTree::Delimited(_, ref delim) => {
                 count_names(&delim.tts)
             }
-            &TokenTree::Token(_, MatchNt(..)) => {
+            TokenTree::Token(_, MatchNt(..)) => {
                 1
             }
-            &TokenTree::Token(_, _) => 0,
+            TokenTree::Token(_, _) => 0,
         }
     })
 }
@@ -203,18 +203,18 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc<NamedMatch>])
             -> HashMap<Name, Rc<NamedMatch>> {
     fn n_rec(p_s: &ParseSess, m: &TokenTree, res: &[Rc<NamedMatch>],
              ret_val: &mut HashMap<Name, Rc<NamedMatch>>, idx: &mut usize) {
-        match m {
-            &TokenTree::Sequence(_, ref seq) => {
+        match *m {
+            TokenTree::Sequence(_, ref seq) => {
                 for next_m in &seq.tts {
                     n_rec(p_s, next_m, res, ret_val, idx)
                 }
             }
-            &TokenTree::Delimited(_, ref delim) => {
+            TokenTree::Delimited(_, ref delim) => {
                 for next_m in &delim.tts {
                     n_rec(p_s, next_m, res, ret_val, idx)
                 }
             }
-            &TokenTree::Token(sp, MatchNt(bind_name, _, _, _)) => {
+            TokenTree::Token(sp, MatchNt(bind_name, _, _, _)) => {
                 match ret_val.entry(bind_name.name) {
                     Vacant(spot) => {
                         spot.insert(res[*idx].clone());
@@ -228,8 +228,8 @@ fn n_rec(p_s: &ParseSess, m: &TokenTree, res: &[Rc<NamedMatch>],
                     }
                 }
             }
-            &TokenTree::Token(_, SubstNt(..)) => panic!("Cannot fill in a NT"),
-            &TokenTree::Token(_, _) => (),
+            TokenTree::Token(_, SubstNt(..)) => panic!("Cannot fill in a NT"),
+            TokenTree::Token(_, _) => (),
         }
     }
     let mut ret_val = HashMap::new();

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 5b8f5c0aef6f78857ade02f6b5e3c7683b72bf7e..d9c9fdd9c90d918e2ca5a3bfd7db07aaf8a6cf40 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1263,13 +1263,13 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                     _ => {}
                 }
 
-                match opt_trait {
-                    &Some(ref t) => {
+                match *opt_trait {
+                    Some(ref t) => {
                         try!(self.print_trait_ref(t));
                         try!(space(&mut self.s));
                         try!(self.word_space("for"));
                     }
-                    &None => {}
+                    None => {}
                 }
 
                 try!(self.print_type(&**ty));
@@ -1499,10 +1499,10 @@ pub fn print_tts(&mut self, tts: &[ast::TokenTree]) -> io::Result<()> {
             try!(self.print_tt(tt));
             // There should be no space between the module name and the following `::` in paths,
             // otherwise imported macros get re-parsed from crate metadata incorrectly (#20701)
-            suppress_space = match tt {
-                &TokenTree::Token(_, token::Ident(_, token::ModName)) |
-                &TokenTree::Token(_, token::MatchNt(_, _, _, token::ModName)) |
-                &TokenTree::Token(_, token::SubstNt(_, token::ModName)) => true,
+            suppress_space = match *tt {
+                TokenTree::Token(_, token::Ident(_, token::ModName)) |
+                TokenTree::Token(_, token::MatchNt(_, _, _, token::ModName)) |
+                TokenTree::Token(_, token::SubstNt(_, token::ModName)) => true,
                 _ => false
             }
         }
@@ -2618,8 +2618,8 @@ pub fn print_fn_args(&mut self, decl: &ast::FnDecl,
         try!(self.rbox(0, Inconsistent));
         let mut first = true;
         if let Some(explicit_self) = opt_explicit_self {
-            let m = match explicit_self {
-                &ast::SelfStatic => ast::MutImmutable,
+            let m = match *explicit_self {
+                ast::SelfStatic => ast::MutImmutable,
                 _ => match decl.inputs[0].pat.node {
                     ast::PatIdent(ast::BindByValue(m), _, _) => m,
                     _ => ast::MutImmutable
@@ -2804,18 +2804,18 @@ pub fn print_where_clause(&mut self, where_clause: &ast::WhereClause)
                 try!(self.word_space(","));
             }
 
-            match predicate {
-                &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bound_lifetimes,
-                                                                              ref bounded_ty,
-                                                                              ref bounds,
-                                                                              ..}) => {
+            match *predicate {
+                ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bound_lifetimes,
+                                                                             ref bounded_ty,
+                                                                             ref bounds,
+                                                                             ..}) => {
                     try!(self.print_formal_lifetime_list(bound_lifetimes));
                     try!(self.print_type(&**bounded_ty));
                     try!(self.print_bounds(":", bounds));
                 }
-                &ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime,
-                                                                                ref bounds,
-                                                                                ..}) => {
+                ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime,
+                                                                               ref bounds,
+                                                                               ..}) => {
                     try!(self.print_lifetime(lifetime));
                     try!(word(&mut self.s, ":"));
 
@@ -2827,7 +2827,7 @@ pub fn print_where_clause(&mut self, where_clause: &ast::WhereClause)
                         }
                     }
                 }
-                &ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref path, ref ty, ..}) => {
+                ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref path, ref ty, ..}) => {
                     try!(self.print_path(path, false, 0));
                     try!(space(&mut self.s));
                     try!(self.word_space("="));

diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 7cd44e5fb4eff2d82a7fc1226fe9d6e8e5fac678..3e02476443a990a04ea1822606cda11ea8c00d9a 100644 (file)
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -353,8 +353,8 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
     let has_test_attr = attr::contains_name(&i.attrs, "test");
 
     fn has_test_signature(i: &ast::Item) -> HasTestSignature {
-        match &i.node {
-          &ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
+        match i.node {
+          ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
             let no_output = match decl.output {
                 ast::DefaultReturn(..) => true,
                 ast::Return(ref t) if t.node == ast::TyTup(vec![]) => true,

diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index a35a1c1cffd28f3342c4ded7d31d5a1794b9db7f..d4b95cbed177fb0d427cb946a7f3769e14120dfc 100644 (file)
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -496,25 +496,25 @@ pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics
     }
     walk_list!(visitor, visit_lifetime_def, &generics.lifetimes);
     for predicate in &generics.where_clause.predicates {
-        match predicate {
-            &WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty,
-                                                                          ref bounds,
-                                                                          ref bound_lifetimes,
-                                                                          ..}) => {
+        match *predicate {
+            WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty,
+                                                               ref bounds,
+                                                               ref bound_lifetimes,
+                                                               ..}) => {
                 visitor.visit_ty(bounded_ty);
                 walk_list!(visitor, visit_ty_param_bound, bounds);
                 walk_list!(visitor, visit_lifetime_def, bound_lifetimes);
             }
-            &WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime,
-                                                                            ref bounds,
-                                                                            ..}) => {
+            WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime,
+                                                                 ref bounds,
+                                                                 ..}) => {
                 visitor.visit_lifetime(lifetime);
                 walk_list!(visitor, visit_lifetime, bounds);
             }
-            &WherePredicate::EqPredicate(WhereEqPredicate{id,
-                                                                    ref path,
-                                                                    ref ty,
-                                                                    ..}) => {
+            WherePredicate::EqPredicate(WhereEqPredicate{id,
+                                                         ref path,
+                                                         ref ty,
+                                                         ..}) => {
                 visitor.visit_path(path, id);
                 visitor.visit_ty(ty);
             }