[librsvg] De-reference Parser's tokens when matching, for legibility

[Federico Mena Quintero <federico src gnome org>]

commit 951555887a5b03280d04c17b8f85a3490bd6f0f3
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon Jul 31 16:45:56 2017 -0500

    De-reference Parser's tokens when matching, for legibility

 rust/src/length.rs  |   18 +++++++++---------
 rust/src/opacity.rs |    8 ++++----
 rust/src/parsers.rs |   10 +++++-----
 3 files changed, 18 insertions(+), 18 deletions(-)
---
diff --git a/rust/src/length.rs b/rust/src/length.rs
index 1ad1d95..6562cf5 100644
--- a/rust/src/length.rs
+++ b/rust/src/length.rs
@@ -109,16 +109,16 @@ impl RsvgLength {
             let token = parser.next ()
                 .map_err (|_| AttributeError::Parse (ParseError::new ("expected number and optional symbol, 
or number and percentage")))?;
 
-            match token {
-                &Token::Number { value, .. } => RsvgLength { length: value as f64,
-                                                             unit:   LengthUnit::Default,
-                                                             dir:    dir },
+            match *token {
+                Token::Number { value, .. } => RsvgLength { length: value as f64,
+                                                            unit:   LengthUnit::Default,
+                                                            dir:    dir },
 
-                &Token::Percentage { unit_value, .. } => RsvgLength { length: unit_value as f64,
-                                                                      unit:   LengthUnit::Percent,
-                                                                      dir:    dir },
+                Token::Percentage { unit_value, .. } => RsvgLength { length: unit_value as f64,
+                                                                     unit:   LengthUnit::Percent,
+                                                                     dir:    dir },
 
-                &Token::Dimension { value, ref unit, .. } => {
+                Token::Dimension { value, ref unit, .. } => {
                     let value = value as f64;
 
                     match unit.as_ref () {
@@ -159,7 +159,7 @@ impl RsvgLength {
                 },
 
                 // FIXME: why are the following in Length?  They should be in FontSize
-                &Token::Ident (ref cow) => match cow.as_ref () {
+                Token::Ident (ref cow) => match cow.as_ref () {
                     "larger" => RsvgLength { length: 0.0,
                                              unit:   LengthUnit::RelativeLarger,
                                              dir:    dir },
diff --git a/rust/src/opacity.rs b/rust/src/opacity.rs
index 61aed77..84f2907 100644
--- a/rust/src/opacity.rs
+++ b/rust/src/opacity.rs
@@ -78,16 +78,16 @@ impl FromStr for Opacity {
             let token = parser.next ()
                 .map_err (|_| make_err ())?;
 
-            match token {
-                &Token::Ident (ref value) => {
-                    if value.as_ref () == "inherit" {
+            match *token {
+                Token::Ident (ref cow) => {
+                    if cow.as_ref () == "inherit" {
                         Opacity::Inherit
                     } else {
                         return Err (make_err ());
                     }
                 },
 
-                &Token::Number { value, .. } => {
+                Token::Number { value, .. } => {
                     if value < 0.0 {
                         Opacity::Specified (0.0)
                     } else if value > 1.0 {
diff --git a/rust/src/parsers.rs b/rust/src/parsers.rs
index 7220ac5..70d2449 100644
--- a/rust/src/parsers.rs
+++ b/rust/src/parsers.rs
@@ -41,24 +41,24 @@ pub fn angle_degrees (s: &str) -> Result <f64, ParseError> {
         let token = parser.next ()
             .map_err (|_| ParseError::new ("expected angle"))?;
 
-        match token {
-            &Token::Number { value, .. } => value as f64,
+        match *token {
+            Token::Number { value, .. } => value as f64,
 
-            &Token::Dimension { value, ref unit, .. } => {
+            Token::Dimension { value, ref unit, .. } => {
                 let value = value as f64;
 
                 match unit.as_ref () {
                     "deg"  => value,
                     "grad" => value * 360.0 / 400.0,
                     "rad"  => value * 180.0 / PI,
-                    _      => return Err (ParseError::new ("expected angle"))
+                    _      => return Err (ParseError::new ("expected 'deg' | 'grad' | 'rad'"))
                 }
             },
 
             _ => return Err (ParseError::new ("expected angle"))
         }
     };
-    
+
     parser.expect_exhausted ().map_err (|_| ParseError::new ("expected angle"))?;
 
     Ok (angle)