1 files changed, 65 insertions, 11 deletions

diff --git a/src/eval/analysis.rs b/src/eval/analysis.rs
index b3a0083..d5a7165 100644
--- a/src/eval/analysis.rs
+++ b/src/eval/analysis.rs
@@ -6,10 +6,17 @@ pub struct Analysis {
 }
 
 impl Analysis {
-    pub fn print(&self) {
+    pub fn contains_error(&self) -> bool {
+        self.diagnostics.iter().any(|d| d.level == Level::Error)
+    }
+}
+
+impl std::fmt::Display for Analysis {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for Diagnostic { level, kind } in &self.diagnostics {
-            eprintln!("{level} {kind}");
+            writeln!(f, "{level} {kind}")?;
         }
+        Ok(())
     }
 }
 
@@ -36,16 +43,20 @@ impl std::fmt::Display for Level {
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum Kind {
-    Pattern {
+    InvalidPattern {
         invalid_node_kind: String,
         full_pattern: ast::Pattern,
     },
+    SimplifiablePattern {
+        pattern: ast::TreePattern,
+        simplified: ast::TreePattern,
+    },
 }
 
 impl std::fmt::Display for Kind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Pattern {
+            Self::InvalidPattern {
                 invalid_node_kind,
                 full_pattern,
             } => {
@@ -54,12 +65,21 @@ impl std::fmt::Display for Kind {
                     "invalid node kind `{invalid_node_kind}` in pattern `{full_pattern}`"
                 )
             }
+            Self::SimplifiablePattern {
+                pattern,
+                simplified,
+            } => {
+                write!(
+                    f,
+                    "the pattern `{pattern}` can be reduced to just `{simplified}`"
+                )
+            }
         }
     }
 }
 
 pub fn run(ctx: &super::Context) -> Analysis {
-    [validate_patterns(ctx)]
+    [validate_patterns(ctx), redundant_list_pattern(ctx)]
         .into_iter()
         .flatten()
         .collect::<Vec<_>>()
@@ -67,11 +87,9 @@ pub fn run(ctx: &super::Context) -> Analysis {
 }
 
 fn validate_patterns(ctx: &super::Context) -> Vec<Diagnostic> {
-    fn validate_pattern(
-        pattern: &ast::TreePattern,
-        language: &tree_sitter::Language,
-    ) -> Option<String> {
+    fn check(pattern: &ast::TreePattern, language: &tree_sitter::Language) -> Option<String> {
         match pattern {
+            // base case
             ast::TreePattern::Atom(a) => {
                 if language.id_for_node_kind(a, true) == 0 {
                     Some(a.to_owned())
@@ -79,9 +97,10 @@ fn validate_patterns(ctx: &super::Context) -> Vec<Diagnostic> {
                     None
                 }
             }
+            // recursive case
             ast::TreePattern::List(items) => {
                 for item in items {
-                    validate_pattern(item, language)?;
+                    check(item, language)?;
                 }
                 None
             }
@@ -94,7 +113,7 @@ fn validate_patterns(ctx: &super::Context) -> Vec<Diagnostic> {
         .flat_map(|s| match &s.pattern {
             ast::Pattern::Begin | ast::Pattern::End => None,
             ast::Pattern::Tree { matcher, .. } => {
-                validate_pattern(matcher, &ctx.language).map(|invalid_node_kind| Kind::Pattern {
+                check(matcher, &ctx.language).map(|invalid_node_kind| Kind::InvalidPattern {
                     invalid_node_kind,
                     full_pattern: s.pattern.clone(),
                 })
@@ -106,3 +125,38 @@ fn validate_patterns(ctx: &super::Context) -> Vec<Diagnostic> {
         })
         .collect()
 }
+
+fn redundant_list_pattern(ctx: &super::Context) -> Vec<Diagnostic> {
+    fn simplify(pattern: &ast::TreePattern) -> ast::TreePattern {
+        match pattern {
+            ast::TreePattern::Atom(a) => ast::TreePattern::Atom(a.to_owned()),
+            ast::TreePattern::List(l) => match l.as_slice() {
+                [a] => simplify(a),
+                items => ast::TreePattern::List(items.iter().map(simplify).collect::<Vec<_>>()),
+            },
+        }
+    }
+
+    ctx.program
+        .stanzas
+        .iter()
+        .flat_map(|s| match &s.pattern {
+            ast::Pattern::Begin | ast::Pattern::End => None,
+            ast::Pattern::Tree { matcher, .. } => {
+                let simplified = simplify(matcher);
+                if &simplified != matcher {
+                    Some(Kind::SimplifiablePattern {
+                        pattern: matcher.clone(),
+                        simplified,
+                    })
+                } else {
+                    None
+                }
+            }
+        })
+        .map(|kind| Diagnostic {
+            level: Level::Warning,
+            kind,
+        })
+        .collect()
+}