zero_or_more_groups: Add more details to results

wrausmt-format/src/text/parse/combinator.rs

@@ -22,13 +22,18 @@ impl<R: Read> Parser<R> {
     /// Attempts to parse a series of items using the provided parse method.
     /// The parse method should return 0 or more of the item type.
     /// Returns the results as a flattened vector of items.
-    pub fn zero_or_more_groups<T>(&mut self, parse: ParseGroupFn<Self, T>) -> Result<Vec<T>> {
+    pub fn zero_or_more_groups<T>(
+        &mut self,
+        parse: ParseGroupFn<Self, T>,
+    ) -> Result<(Vec<T>, bool)> {
         pctx!(self, "zero or more groups");
         let mut result: Vec<T> = vec![];
+        let mut any = false;
         while let Some(t) = parse(self)? {
+            any = true;
             result.extend(t);
         }
-        Ok(result)
+        Ok((result, any))
     }
 
     /// Attempts to parse a series of items using the provided parse method.

wrausmt-format/src/text/parse/instruction.rs

@@ -12,7 +12,7 @@ use {
 impl<R: Read> Parser<R> {
     pub fn parse_instructions(&mut self) -> Result<Vec<Instruction<Unresolved>>> {
         pctx!(self, "parse instructiosn");
-        self.zero_or_more_groups(Self::try_instruction)
+        Ok(self.zero_or_more_groups(Self::try_instruction)?.0)
     }
 
     /// Called at a point where we expect an instruction name keyword
@@ -63,8 +63,8 @@ impl<R: Read> Parser<R> {
                         syntax::Operands::BrTable(idxs, last)
                     }
                     Operands::Select => {
-                        let results = self.zero_or_more_groups(Self::try_parse_fresult)?;
-                        if results.is_empty() {
+                        let (results, any) = self.zero_or_more_groups(Self::try_parse_fresult)?;
+                        if !any {
                             syntax::Operands::None
                         } else {
                             syntax::Operands::SelectT(results)
@@ -244,17 +244,17 @@ impl<R: Read> Parser<R> {
         let location = self.location();
         let label = self.try_id()?;
         let typeuse = self.parse_type_use(super::module::FParamId::Forbidden)?;
-        let condition = self.zero_or_more_groups(Self::try_folded_instruction)?;
+        let (condition, _) = self.zero_or_more_groups(Self::try_folded_instruction)?;
         let mut unfolded = condition;
         let thexpr = if self.try_expr_start("then")? {
-            let instr = self.zero_or_more_groups(Self::try_instruction)?;
+            let (instr, _) = self.zero_or_more_groups(Self::try_instruction)?;
             self.expect_close()?;
             UncompiledExpr { instr }
         } else {
             Err(self.unexpected_token("then"))?
         };
         let elexpr = if self.try_expr_start("else")? {
-            let instr = self.zero_or_more_groups(Self::try_instruction)?;
+            let (instr, _) = self.zero_or_more_groups(Self::try_instruction)?;
             self.expect_close()?;
             UncompiledExpr { instr }
         } else {
@@ -321,7 +321,7 @@ impl<R: Read> Parser<R> {
             None => return Ok(None),
         };
 
-        let mut rest = self.zero_or_more_groups(Self::try_folded_instruction)?;
+        let (mut rest, _) = self.zero_or_more_groups(Self::try_folded_instruction)?;
 
         rest.push(first);
         self.expect_close()?;

wrausmt-format/src/text/parse/module.rs

@@ -188,14 +188,16 @@ impl<R: Read> Parser<R> {
     pub fn try_function_type(&mut self, fparam_id: FParamId) -> Result<FunctionType> {
         pctx!(self, "try function type");
         Ok(FunctionType {
-            params:  self.zero_or_more_groups(match fparam_id {
-                // Using closures makes the combinators a lot more complicated.
-                // For this use case, it's simpler to just create variants for the
-                // two types of FParam variants.
-                FParamId::Allowed => Self::try_parse_fparam_id_allowed,
-                FParamId::Forbidden => Self::try_parse_fparam_id_forbidden,
-            })?,
-            results: self.zero_or_more_groups(Self::try_parse_fresult)?,
+            params:  self
+                .zero_or_more_groups(match fparam_id {
+                    // Using closures makes the combinators a lot more complicated.
+                    // For this use case, it's simpler to just create variants for the
+                    // two types of FParam variants.
+                    FParamId::Allowed => Self::try_parse_fparam_id_allowed,
+                    FParamId::Forbidden => Self::try_parse_fparam_id_forbidden,
+                })?
+                .0,
+            results: self.zero_or_more_groups(Self::try_parse_fresult)?.0,
         })
     }
 
@@ -227,7 +229,7 @@ impl<R: Read> Parser<R> {
             })));
         }
 
-        let locals = self.zero_or_more_groups(Self::try_locals)?;
+        let (locals, _) = self.zero_or_more_groups(Self::try_locals)?;
 
         let instr = self.parse_instructions()?;
         self.expect_close()?;