Address code review

Author: vimpunk

procedural-masquerade/lib.rs

@@ -244,33 +244,33 @@ macro_rules! define_invoke_proc_macro {
         #[doc(hidden)]
         #[macro_export]
         macro_rules! $macro_name {
-                            ($proc_macro_name: ident ! $paren: tt) => {
-                                #[derive($proc_macro_name)]
-                                #[allow(unused)]
-                                enum ProceduralMasqueradeDummyType {
-                                    // The magic happens here.
-                                    //
-                                    // We use an `enum` with an explicit discriminant
-                                    // because that is the only case where a type definition
-                                    // can contain a (const) expression.
-                                    //
-                                    // `(0, "foo").0` evalutes to 0, with the `"foo"` part ignored.
-                                    //
-                                    // By the time the `#[proc_macro_derive]` function
-                                    // implementing `#[derive($proc_macro_name)]` is called,
-                                    // `$paren` has already been replaced with the input of this inner macro,
-                                    // but `stringify!` has not been expanded yet.
-                                    //
-                                    // This how arbitrary tokens can be inserted
-                                    // in the input to the `#[proc_macro_derive]` function.
-                                    //
-                                    // Later, `stringify!(...)` is expanded into a string literal
-                                    // which is then ignored.
-                                    // Using `stringify!` enables passing arbitrary tokens
-                                    // rather than only what can be parsed as a const expression.
-                                    Input = (0, stringify! $paren ).0
+                                    ($proc_macro_name: ident ! $paren: tt) => {
+                                        #[derive($proc_macro_name)]
+                                        #[allow(unused)]
+                                        enum ProceduralMasqueradeDummyType {
+                                            // The magic happens here.
+                                            //
+                                            // We use an `enum` with an explicit discriminant
+                                            // because that is the only case where a type definition
+                                            // can contain a (const) expression.
+                                            //
+                                            // `(0, "foo").0` evalutes to 0, with the `"foo"` part ignored.
+                                            //
+                                            // By the time the `#[proc_macro_derive]` function
+                                            // implementing `#[derive($proc_macro_name)]` is called,
+                                            // `$paren` has already been replaced with the input of this inner macro,
+                                            // but `stringify!` has not been expanded yet.
+                                            //
+                                            // This how arbitrary tokens can be inserted
+                                            // in the input to the `#[proc_macro_derive]` function.
+                                            //
+                                            // Later, `stringify!(...)` is expanded into a string literal
+                                            // which is then ignored.
+                                            // Using `stringify!` enables passing arbitrary tokens
+                                            // rather than only what can be parsed as a const expression.
+                                            Input = (0, stringify! $paren ).0
+                                        }
+                                    }
                                 }
-                            }
-                        }
     };
 }

src/from_bytes.rs

@@ -38,34 +38,27 @@ where
     E: EncodingSupport,
 {
     // https://drafts.csswg.org/css-syntax/#the-input-byte-stream
-    match protocol_encoding_label {
-        None => (),
-        Some(label) => match E::from_label(label) {
-            None => (),
-            Some(protocol_encoding) => return protocol_encoding,
-        },
-    }
+    if let Some(label) = protocol_encoding_label {
+        if let Some(protocol_encoding) = E::from_label(label) {
+            return protocol_encoding;
+        };
+    };
+
     let prefix = b"@charset \"";
     if css.starts_with(prefix) {
         let rest = &css[prefix.len()..];
-        match rest.iter().position(|&b| b == b'"') {
-            None => (),
-            Some(label_length) => {
-                if rest[label_length..].starts_with(b"\";") {
-                    let label = &rest[..label_length];
-                    match E::from_label(label) {
-                        None => (),
-                        Some(charset_encoding) => {
-                            if E::is_utf16_be_or_le(&charset_encoding) {
-                                return E::utf8();
-                            } else {
-                                return charset_encoding;
-                            }
-                        },
+        if let Some(label_length) = rest.iter().position(|&b| b == b'"') {
+            if rest[label_length..].starts_with(b"\";") {
+                let label = &rest[..label_length];
+                if let Some(charset_encoding) = E::from_label(label) {
+                    if E::is_utf16_be_or_le(&charset_encoding) {
+                        return E::utf8();
+                    } else {
+                        return charset_encoding;
                     }
-                }
-            },
-        }
+                };
+            }
+        };
     }
     environment_encoding.unwrap_or_else(E::utf8)
 }

src/parser.rs

@@ -354,9 +354,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
                 ..
             }) => Ok(()),
             Err(e) => unreachable!("Unexpected error encountered: {:?}", e),
-            Ok(t) => Err(start
-                .source_location()
-                .new_basic_unexpected_token_error(t.clone())),
+            Ok(t) => Err(start.source_location().new_basic_unexpected_token_error(t.clone())),
         };
         self.reset(&start);
         result