First attempt at dealing with multiple errors

Author: ratmice

lrlex/src/lib/ctbuilder.rs

@@ -546,6 +546,14 @@ where
                     closure_lexerdef.set_rule_ids(&owned_map);
                     yacc_header.mark_used(&"test_files".to_string());
                     let test_glob = yacc_header.get("test_files");
+                    let mut err_str = None;
+                    let add_error_line = |err_str: &mut Option<String>, line| {
+                        if let Some(err_str) = err_str {
+                            err_str.push_str(&format!("{}\n", line));
+                        } else {
+                            let _ = err_str.insert(format!("{}\n", line));
+                        }
+                    };
                     match test_glob {
                         Some(HeaderValue(_, Value::Setting(Setting::Array(test_globs, _, _)))) => {
                             for setting in test_globs {
@@ -559,22 +567,33 @@ where
                                             if let Some(ext) = path.extension() {
                                                 if let Some(ext) = ext.to_str() {
                                                     if ext.starts_with("grm") {
-                                                        Err(ErrorString("test_files extensions beginning with `grm` are reserved.".into()))?
+                                                        add_error_line(&mut err_str, "test_files extensions beginning with `grm` are reserved.".into());
                                                     }
                                                 }
                                             }
                                             let input = fs::read_to_string(&path)?;
                                             let l: LRNonStreamingLexer<LexerTypesT> =
                                                 closure_lexerdef.lexer(&input);
-                                            for e in rtpb.parse_map(&l, &|_| (), &|_, _| ()).1 {
-                                                Err(format!("parsing {}: {}", path.display(), e))?
+                                            let errs = rtpb.parse_map(&l, &|_| (), &|_, _| ()).1;
+                                            if errs.len() > 1 {
+                                                add_error_line(&mut err_str, format!("While parsing {}:", path.display()));
+                                                for e in errs {
+                                                    add_error_line(&mut err_str, format!("\t{}", e));
+                                                }
+                                            } else if !errs.is_empty() {
+                                                add_error_line(&mut err_str, format!("parsing {}: {}", path.display(), errs[0]));
                                             }
                                         }
                                     }
-                                _ => return Err("Invalid value for setting 'test_files'".into()),
+                                    _ => return Err("Invalid value for setting 'test_files'".into()),
                                 }
                             }
-                            Ok(())
+                            if let Some(err_str) = err_str {
+                                Err(ErrorString(err_str))?
+                            } else {
+                                Ok(())
+                            }
+
                         }
                         Some(_) => Err("Invalid value for setting 'test_files'".into()),
                         None => Ok(()),