Remove parse command; deduplicate cascading errors

Author: henrygarner

crates/allium-parser/src/parser.rs

@@ -116,6 +116,14 @@ impl<'s> Parser<'s> {
     }
 
     fn error(&mut self, span: Span, msg: impl Into<String>) {
+        let line = self.source_map.line_col(span.start).0;
+        if let Some(last) = self.diagnostics.last() {
+            if last.severity == crate::diagnostic::Severity::Error
+                && self.source_map.line_col(last.span.start).0 == line
+            {
+                return;
+            }
+        }
         self.diagnostics.push(Diagnostic::error(span, msg));
     }
 
@@ -2605,8 +2613,18 @@ rule ProcessDigests {
 
     #[test]
     fn error_recovery_multiple() {
-        // Parser should recover and report multiple errors
+        // Parser should recover and report multiple errors (on separate lines)
         let r = parse("entity E { + }\nentity F { - }");
         assert!(r.diagnostics.len() >= 2, "expected at least 2 errors, got {}", r.diagnostics.len());
     }
+
+    #[test]
+    fn error_dedup_same_line() {
+        // Multiple bad tokens on a single line should produce only one error
+        let r = parse("-- allium: 1\n+ - * /");
+        let errors: Vec<_> = r.diagnostics.iter()
+            .filter(|d| d.severity == crate::diagnostic::Severity::Error)
+            .collect();
+        assert_eq!(errors.len(), 1, "expected 1 error for same-line bad tokens, got {}", errors.len());
+    }
 }

crates/allium/src/main.rs

@@ -9,16 +9,14 @@ fn main() -> ExitCode {
     if args.is_empty() || args[0] == "--help" || args[0] == "-h" {
         eprintln!("Usage: allium check <file.allium>...");
         eprintln!("       allium check <directory>");
-        eprintln!("       allium parse <file.allium> [--json]");
         return ExitCode::from(2);
     }
 
     match args[0].as_str() {
         "check" => cmd_check(&args[1..]),
-        "parse" => cmd_parse(&args[1..]),
         other => {
             eprintln!("Unknown command: {other}");
-            eprintln!("Available commands: check, parse");
+            eprintln!("Available commands: check");
             ExitCode::from(2)
         }
     }
@@ -81,110 +79,6 @@ fn cmd_check(args: &[String]) -> ExitCode {
     }
 }
 
-fn cmd_parse(args: &[String]) -> ExitCode {
-    let json_mode = args.iter().any(|a| a == "--json");
-    let files: Vec<&str> = args.iter().map(|s| s.as_str()).filter(|s| *s != "--json").collect();
-
-    if files.is_empty() {
-        eprintln!("Usage: allium parse <file.allium> [--json]");
-        return ExitCode::from(2);
-    }
-
-    let source = match std::fs::read_to_string(files[0]) {
-        Ok(s) => s,
-        Err(e) => {
-            eprintln!("{}: {e}", files[0]);
-            return ExitCode::from(1);
-        }
-    };
-
-    let result = allium_parser::parse(&source);
-
-    if json_mode {
-        // Minimal JSON output: just diagnostics for now.
-        // Full AST serialisation can come later with serde.
-        println!("{{");
-        println!("  \"file\": {:?},", files[0]);
-        println!("  \"version\": {:?},", result.module.version);
-        println!("  \"declarations\": {},", result.module.declarations.len());
-        println!("  \"diagnostics\": [");
-        let source_map = SourceMap::new(&source);
-        for (i, d) in result.diagnostics.iter().enumerate() {
-            let (line, col) = source_map.line_col(d.span.start);
-            let severity = match d.severity {
-                Severity::Error => "error",
-                Severity::Warning => "warning",
-            };
-            let comma = if i + 1 < result.diagnostics.len() { "," } else { "" };
-            println!(
-                "    {{\"line\": {}, \"col\": {}, \"severity\": \"{severity}\", \"message\": {:?}}}{}",
-                line + 1,
-                col + 1,
-                d.message,
-                comma,
-            );
-        }
-        println!("  ]");
-        println!("}}");
-    } else {
-        println!("Parsed: {}", files[0]);
-        if let Some(v) = result.module.version {
-            println!("Version: {v}");
-        }
-        println!("Declarations: {}", result.module.declarations.len());
-        for d in &result.module.declarations {
-            println!("  {}", describe_decl(d));
-        }
-        if !result.diagnostics.is_empty() {
-            let source_map = SourceMap::new(&source);
-            println!("Diagnostics:");
-            for d in &result.diagnostics {
-                let (line, col) = source_map.line_col(d.span.start);
-                let severity = match d.severity {
-                    Severity::Error => "error",
-                    Severity::Warning => "warning",
-                };
-                println!("  {}:{}: {severity}: {}", line + 1, col + 1, d.message);
-                print_source_snippet(&source_map, &source, line, col);
-            }
-        }
-    }
-
-    if result.diagnostics.iter().any(|d| d.severity == Severity::Error) {
-        ExitCode::from(1)
-    } else {
-        ExitCode::SUCCESS
-    }
-}
-
-fn describe_decl(decl: &allium_parser::ast::Decl) -> String {
-    use allium_parser::ast::*;
-    match decl {
-        Decl::ModuleDecl(m) => format!("module {}", m.name.name),
-        Decl::Use(u) => {
-            let alias = u.alias.as_ref().map(|a| format!(" as {}", a.name)).unwrap_or_default();
-            format!("use {:?}{alias}", u.path.parts.iter().map(|p| match p {
-                StringPart::Text(t) => t.as_str(),
-                _ => "{...}",
-            }).collect::<String>())
-        }
-        Decl::Block(b) => {
-            let name = b.name.as_ref().map(|n| n.name.as_str()).unwrap_or("(anonymous)");
-            format!("{:?} {name} ({} items)", b.kind, b.items.len())
-        }
-        Decl::Default(d) => format!("default {}", d.name.name),
-        Decl::Variant(v) => format!("variant {} : {:?}", v.name.name, v.base),
-        Decl::Deferred(_) => "deferred ...".to_string(),
-        Decl::OpenQuestion(q) => {
-            let text: String = q.text.parts.iter().map(|p| match p {
-                StringPart::Text(t) => t.clone(),
-                StringPart::Interpolation(id) => format!("{{{}}}", id.name),
-            }).collect();
-            format!("open question \"{text}\"")
-        }
-    }
-}
-
 fn print_source_snippet(source_map: &SourceMap, source: &str, line: u32, col: u32) {
     let line_text = source_map.line_text(source, line);
     let line_num = format!("{}", line + 1);