Remove use of 'ref'

Author: dtolnay

src/fallback.rs

@@ -93,8 +93,8 @@ impl fmt::Display for TokenStream {
                 write!(f, " ")?;
             }
             joint = false;
-            match *tt {
-                TokenTree::Group(ref tt) => {
+            match tt {
+                TokenTree::Group(tt) => {
                     let (start, end) = match tt.delimiter() {
                         Delimiter::Parenthesis => ("(", ")"),
                         Delimiter::Brace => ("{", "}"),
@@ -107,15 +107,15 @@ impl fmt::Display for TokenStream {
                         write!(f, "{} {} {}", start, tt.stream(), end)?
                     }
                 }
-                TokenTree::Ident(ref tt) => write!(f, "{}", tt)?,
-                TokenTree::Punct(ref tt) => {
+                TokenTree::Ident(tt) => write!(f, "{}", tt)?,
+                TokenTree::Punct(tt) => {
                     write!(f, "{}", tt.as_char())?;
                     match tt.spacing() {
                         Spacing::Alone => {}
                         Spacing::Joint => joint = true,
                     }
                 }
-                TokenTree::Literal(ref tt) => write!(f, "{}", tt)?,
+                TokenTree::Literal(tt) => write!(f, "{}", tt)?,
             }
         }
 

src/lib.rs

@@ -468,11 +468,11 @@ impl TokenTree {
     /// Returns the span of this tree, delegating to the `span` method of
     /// the contained token or a delimited stream.
     pub fn span(&self) -> Span {
-        match *self {
-            TokenTree::Group(ref t) => t.span(),
-            TokenTree::Ident(ref t) => t.span(),
-            TokenTree::Punct(ref t) => t.span(),
-            TokenTree::Literal(ref t) => t.span(),
+        match self {
+            TokenTree::Group(t) => t.span(),
+            TokenTree::Ident(t) => t.span(),
+            TokenTree::Punct(t) => t.span(),
+            TokenTree::Literal(t) => t.span(),
         }
     }
 
@@ -482,11 +482,11 @@ impl TokenTree {
     /// the span of each of the internal tokens, this will simply delegate to
     /// the `set_span` method of each variant.
     pub fn set_span(&mut self, span: Span) {
-        match *self {
-            TokenTree::Group(ref mut t) => t.set_span(span),
-            TokenTree::Ident(ref mut t) => t.set_span(span),
-            TokenTree::Punct(ref mut t) => t.set_span(span),
-            TokenTree::Literal(ref mut t) => t.set_span(span),
+        match self {
+            TokenTree::Group(t) => t.set_span(span),
+            TokenTree::Ident(t) => t.set_span(span),
+            TokenTree::Punct(t) => t.set_span(span),
+            TokenTree::Literal(t) => t.set_span(span),
         }
     }
 }
@@ -521,11 +521,11 @@ impl From<Literal> for TokenTree {
 /// numeric literals.
 impl fmt::Display for TokenTree {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            TokenTree::Group(ref t) => t.fmt(f),
-            TokenTree::Ident(ref t) => t.fmt(f),
-            TokenTree::Punct(ref t) => t.fmt(f),
-            TokenTree::Literal(ref t) => t.fmt(f),
+        match self {
+            TokenTree::Group(t) => t.fmt(f),
+            TokenTree::Ident(t) => t.fmt(f),
+            TokenTree::Punct(t) => t.fmt(f),
+            TokenTree::Literal(t) => t.fmt(f),
         }
     }
 }
@@ -535,16 +535,16 @@ impl fmt::Debug for TokenTree {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Each of these has the name in the struct type in the derived debug,
         // so don't bother with an extra layer of indirection
-        match *self {
-            TokenTree::Group(ref t) => t.fmt(f),
-            TokenTree::Ident(ref t) => {
+        match self {
+            TokenTree::Group(t) => t.fmt(f),
+            TokenTree::Ident(t) => {
                 let mut debug = f.debug_struct("Ident");
                 debug.field("sym", &format_args!("{}", t));
                 imp::debug_span_field_if_nontrivial(&mut debug, t.span().inner);
                 debug.finish()
             }
-            TokenTree::Punct(ref t) => t.fmt(f),
-            TokenTree::Literal(ref t) => t.fmt(f),
+            TokenTree::Punct(t) => t.fmt(f),
+            TokenTree::Literal(t) => t.fmt(f),
         }
     }
 }

tests/test.rs

@@ -190,7 +190,7 @@ fn span_test() {
                 assert_eq!(end.column, ecol, "ecol did not match for {}", i);
 
                 match i {
-                    TokenTree::Group(ref g) => {
+                    TokenTree::Group(g) => {
                         check_spans_internal(g.stream().clone(), lines);
                     }
                     _ => {}
@@ -289,28 +289,28 @@ fn tricky_doc_comment() {
     let stream = "/// doc".parse::<TokenStream>().unwrap();
     let tokens = stream.into_iter().collect::<Vec<_>>();
     assert!(tokens.len() == 2, "not length 2 -- {:?}", tokens);
-    match tokens[0] {
-        TokenTree::Punct(ref tt) => assert_eq!(tt.as_char(), '#'),
+    match &tokens[0] {
+        TokenTree::Punct(tt) => assert_eq!(tt.as_char(), '#'),
         _ => panic!("wrong token {:?}", tokens[0]),
     }
-    let mut tokens = match tokens[1] {
-        TokenTree::Group(ref tt) => {
+    let mut tokens = match &tokens[1] {
+        TokenTree::Group(tt) => {
             assert_eq!(tt.delimiter(), Delimiter::Bracket);
             tt.stream().into_iter()
         }
         _ => panic!("wrong token {:?}", tokens[0]),
     };
 
     match tokens.next().unwrap() {
-        TokenTree::Ident(ref tt) => assert_eq!(tt.to_string(), "doc"),
+        TokenTree::Ident(tt) => assert_eq!(tt.to_string(), "doc"),
         t => panic!("wrong token {:?}", t),
     }
     match tokens.next().unwrap() {
-        TokenTree::Punct(ref tt) => assert_eq!(tt.as_char(), '='),
+        TokenTree::Punct(tt) => assert_eq!(tt.as_char(), '='),
         t => panic!("wrong token {:?}", t),
     }
     match tokens.next().unwrap() {
-        TokenTree::Literal(ref tt) => {
+        TokenTree::Literal(tt) => {
             assert_eq!(tt.to_string(), "\" doc\"");
         }
         t => panic!("wrong token {:?}", t),