Refactor module parsing function.

The logic of parsing a module macro is a little bit cumbersome and
error-prone. Refactor this part to make it clear, concise, structural
and extensible.

Signed-off-by: d0u9 <d0u9.su@outlook.com>

Author: d0u9

rust/macros/module.rs

@@ -313,17 +313,17 @@ impl ModuleInfo {
     fn parse(it: &mut token_stream::IntoIter) -> Self {
         let mut info = ModuleInfo::default();
 
-        const EXPECTED_KEYS: &[&str] = &[
-            "type",
-            "name",
-            "author",
-            "description",
-            "license",
-            "alias",
-            "alias_rtnl_link",
-            "params",
+        const KEYS_AND_ACTIONS: &[(bool, &str, fn(&mut ModuleInfo, &mut token_stream::IntoIter))] = &[
+            (true,  "type",             ModuleInfo::set_type),
+            (true,  "name",             ModuleInfo::set_name),
+            (false, "author",           ModuleInfo::set_author),
+            (false, "description",      ModuleInfo::set_description),
+            (true,  "license",          ModuleInfo::set_license),
+            (false, "alias",            ModuleInfo::set_alias),
+            (false, "alias_rtnl_link",  ModuleInfo::set_alias_rtnl_link),
+            (false, "params",           ModuleInfo::set_params),
         ];
-        const REQUIRED_KEYS: &[&str] = &["type", "name", "license"];
+
         let mut seen_keys = Vec::new();
 
         loop {
@@ -333,61 +333,88 @@ impl ModuleInfo {
                 None => break,
             };
 
-            if seen_keys.contains(&key) {
+            assert_eq!(expect_punct(it), ':');
+
+            let action = KEYS_AND_ACTIONS.iter()
+                        .find(|x| x.1 == key.as_str())
+                        .expect(format!("Unknown key \"{}\". Valid keys are: {:?}.",
+                            key,
+                            KEYS_AND_ACTIONS.iter()
+                                .map(|x| format!("{}, ", x.1.to_string()))
+                                .collect::<String>()
+                        ).as_str());
+
+            if seen_keys.contains(&action.1) {
                 panic!(
                     "Duplicated key \"{}\". Keys can only be specified once.",
                     key
                 );
-            }
-
-            assert_eq!(expect_punct(it), ':');
-
-            match key.as_str() {
-                "type" => info.type_ = expect_ident(it),
-                "name" => info.name = expect_byte_string(it),
-                "author" => info.author = Some(expect_byte_string(it)),
-                "description" => info.description = Some(expect_byte_string(it)),
-                "license" => info.license = expect_byte_string(it),
-                "alias" => info.alias = Some(expect_byte_string(it)),
-                "alias_rtnl_link" => {
-                    info.alias = Some(format!("rtnl-link-{}", expect_byte_string(it)))
-                }
-                "params" => info.params = Some(expect_group(it)),
-                _ => panic!(
-                    "Unknown key \"{}\". Valid keys are: {:?}.",
-                    key, EXPECTED_KEYS
-                ),
+            } else {
+                action.2(&mut info, it);
             }
 
             assert_eq!(expect_punct(it), ',');
 
-            seen_keys.push(key);
+            seen_keys.push(&action.1);
         }
 
         expect_end(it);
 
-        for key in REQUIRED_KEYS {
-            if !seen_keys.iter().any(|e| e == key) {
-                panic!("Missing required key \"{}\".", key);
+        let mut ordered_keys: Vec<&str> = Vec::new();
+        for action in KEYS_AND_ACTIONS.iter() {
+            let has_key = seen_keys.iter().any(|e| e == &action.1);
+            if action.0 && !has_key {
+                panic!("Missing required key \"{}\".", action.1);
             }
-        }
 
-        let mut ordered_keys: Vec<&str> = Vec::new();
-        for key in EXPECTED_KEYS {
-            if seen_keys.iter().any(|e| e == key) {
-                ordered_keys.push(key);
+            if has_key {
+                ordered_keys.push(&action.1);
             }
         }
 
         if seen_keys != ordered_keys {
             panic!(
                 "Keys are not ordered as expected. Order them like: {:?}.",
-                ordered_keys
+                ordered_keys,
             );
         }
 
+
         info
     }
+
+    fn set_name(&mut self, it: &mut token_stream::IntoIter) {
+        self.name = expect_byte_string(it);
+    }
+
+    fn set_type(&mut self, it: &mut token_stream::IntoIter) {
+        self.type_ = expect_ident(it);
+    }
+
+    fn set_license(&mut self, it: &mut token_stream::IntoIter) {
+        self.license = expect_byte_string(it);
+    }
+
+    fn set_author(&mut self, it: &mut token_stream::IntoIter) {
+        self.author = Some(expect_byte_string(it));
+    }
+
+    fn set_description(&mut self, it: &mut token_stream::IntoIter) {
+        self.description = Some(expect_byte_string(it));
+    }
+
+    fn set_alias(&mut self, it: &mut token_stream::IntoIter) {
+        self.alias = Some(expect_byte_string(it))
+    }
+
+    fn set_alias_rtnl_link(&mut self, it: &mut token_stream::IntoIter) {
+        self.alias = Some(format!("rtnl-link-{}", expect_byte_string(it)))
+    }
+
+    fn set_params(&mut self, it: &mut token_stream::IntoIter) {
+        self.params = Some(expect_group(it))
+    }
+
 }
 
 pub fn module(ts: TokenStream) -> TokenStream {