gsd-parser: Clean up some overly verbose expect() calls

It is fine to use unwrap() here.

Author: Rahix

gsd-parser/src/parser.rs

@@ -116,7 +116,7 @@ fn parse_inner(
 
     let gsd_pairs = gsd_parser::GsdParser::parse(gsd_parser::Rule::gsd, source)?
         .next()
-        .expect("pest grammar wrong?");
+        .unwrap();
 
     let start_pos = gsd_pairs.as_span().start_pos();
 
@@ -133,13 +133,13 @@ fn parse_inner(
         match statement.as_rule() {
             gsd_parser::Rule::prm_text => {
                 let mut content = statement.into_inner();
-                let id: u16 = parse_number(content.next().expect("pest grammar wrong?"))?;
+                let id: u16 = parse_number(content.next().unwrap())?;
                 let mut values = BTreeMap::new();
                 for value_pairs in content {
                     assert!(value_pairs.as_rule() == gsd_parser::Rule::prm_text_value);
                     let mut iter = value_pairs.into_inner();
-                    let number = parse_signed_number(iter.next().expect("pest grammar wrong?"))?;
-                    let value = parse_string_literal(iter.next().expect("pest grammar wrong?"));
+                    let number = parse_signed_number(iter.next().unwrap())?;
+                    let value = parse_string_literal(iter.next().unwrap());
                     assert!(iter.next().is_none());
                     values.insert(value, number);
                 }
@@ -148,18 +148,15 @@ fn parse_inner(
             gsd_parser::Rule::ext_user_prm_data => {
                 let mut content = statement.into_inner();
                 // TODO: actually u32?
-                let id: u32 = parse_number(content.next().expect("pest grammar wrong?"))?;
-                let name = parse_string_literal(content.next().expect("pest grammar wrong?"));
+                let id: u32 = parse_number(content.next().unwrap())?;
+                let name = parse_string_literal(content.next().unwrap());
 
-                let data_type_pair = content.next().expect("pest grammar wrong?");
+                let data_type_pair = content.next().unwrap();
                 assert_eq!(
                     data_type_pair.as_rule(),
                     gsd_parser::Rule::prm_data_type_name
                 );
-                let data_type_rule = data_type_pair
-                    .into_inner()
-                    .next()
-                    .expect("pest grammar wrong?");
+                let data_type_rule = data_type_pair.into_inner().next().unwrap();
                 let data_type = match data_type_rule.as_rule() {
                     gsd_parser::Rule::identifier => {
                         match data_type_rule.as_str().to_lowercase().as_str() {
@@ -173,25 +170,19 @@ fn parse_inner(
                         }
                     }
                     gsd_parser::Rule::bit => {
-                        let bit = parse_number(
-                            data_type_rule
-                                .into_inner()
-                                .next()
-                                .expect("pest grammar wrong?"),
-                        )?;
+                        let bit = parse_number(data_type_rule.into_inner().next().unwrap())?;
                         crate::UserPrmDataType::Bit(bit)
                     }
                     gsd_parser::Rule::bit_area => {
                         let mut content = data_type_rule.into_inner();
-                        let first_bit = parse_number(content.next().expect("pest grammar wrong?"))?;
-                        let last_bit = parse_number(content.next().expect("pest grammar wrong?"))?;
+                        let first_bit = parse_number(content.next().unwrap())?;
+                        let last_bit = parse_number(content.next().unwrap())?;
                         crate::UserPrmDataType::BitArea(first_bit, last_bit)
                     }
                     _ => unreachable!(),
                 };
 
-                let default_value =
-                    parse_signed_number(content.next().expect("pest grammar wrong?"))?;
+                let default_value = parse_signed_number(content.next().unwrap())?;
 
                 let mut constraint = crate::PrmValueConstraint::Unconstrained;
                 let mut text_ref = None;
@@ -202,10 +193,8 @@ fn parse_inner(
                     match rule.as_rule() {
                         gsd_parser::Rule::prm_data_value_range => {
                             let mut content = rule.into_inner();
-                            let min_value =
-                                parse_signed_number(content.next().expect("pest grammar wrong?"))?;
-                            let max_value =
-                                parse_signed_number(content.next().expect("pest grammar wrong?"))?;
+                            let min_value = parse_signed_number(content.next().unwrap())?;
+                            let max_value = parse_signed_number(content.next().unwrap())?;
                             constraint = crate::PrmValueConstraint::MinMax(min_value, max_value);
                         }
                         gsd_parser::Rule::prm_data_value_set => {
@@ -217,9 +206,7 @@ fn parse_inner(
                             constraint = crate::PrmValueConstraint::Enum(values);
                         }
                         gsd_parser::Rule::prm_text_ref => {
-                            let text_id = parse_number(
-                                rule.into_inner().next().expect("pest grammar wrong?"),
-                            )?;
+                            let text_id = parse_number(rule.into_inner().next().unwrap())?;
                             text_ref = Some(
                                 prm_texts
                                     .get(&text_id)