Track icase with booleans, not separate enum vals

peg_macro/src/lib.rs

@@ -24,14 +24,12 @@ enum Term {
     AnyChar,
     Choice(Vec<Term>),
     EOI,
-    Literal(String),
+    Literal(String, bool),
-    LiteralI(String),
     NegLookahead(Box<Term>),
     Optional(Box<Term>),
     Plus(Box<Term>),
     PosLookahead(Box<Term>),
-    Range(RangeInclusive<char>),
+    Range(RangeInclusive<char>, bool),
-    RangeI(RangeInclusive<char>),
     Rule(Ident),
     Sequence(Vec<Term>),
     Star(Box<Term>),
@@ -66,11 +64,8 @@ impl Parse for Term {
             input.parse::<Token![..]>()?;
             let end_lit = input.parse::<LitChar>()?;
             let range = start_lit.value()..=end_lit.value();
-            if end_lit.suffix() == "i" {
+            let icase = end_lit.suffix() == "i";
-                Ok(Term::RangeI(range))
+            Ok(Term::Range(range, icase))
-            } else {
-                Ok(Term::Range(range))
-            }
         }
 
         fn parse_atom(input: ParseStream) -> syn::Result<Term> {
@@ -85,11 +80,8 @@ impl Parse for Term {
                 }
             } else if look.peek(LitStr) {
                 let lit = input.parse::<LitStr>()?;
-                if lit.suffix() == "i" {
+                let icase = lit.suffix() == "i";
-                    Ok(Term::LiteralI(lit.value()))
+                Ok(Term::Literal(lit.value(), icase))
-                } else {
-                    Ok(Term::Literal(lit.value()))
-                }
             } else if look.peek(LitChar) {
                 parse_range(input)
             } else if look.peek(syn::token::Paren) {
@@ -168,12 +160,16 @@ impl Term {
             Term::Rule(ident) => quote! {
                 #ident(p)
             },
-            Term::Literal(lit_str) => quote! {
+            Term::Literal(lit_str, icase) => {
-                p.literal(#lit_str)
+                let method = if *icase {
-            },
+                    quote! { literal_i }
-            Term::LiteralI(lit_str) => quote! {
+                } else {
-                p.literal_i(#lit_str)
+                    quote! { literal }
-            },
+                };
+                quote! {
+                    p.#method(#lit_str)
+                }
+            }
             Term::Sequence(terms) => {
                 let expr = terms
                     .iter()
@@ -227,16 +223,15 @@ impl Term {
                     }
                 }
             }
-            Term::Range(range) => {
+            Term::Range(range, icase) => {
                 let (lo, hi) = (range.start(), range.end());
+                let method = if *icase {
+                    quote! { range_i }
+                } else {
+                    quote! { range }
+                };
                 quote! {
-                    p.range(#lo..=#hi)
+                    p.#method(#lo..=#hi)
-                }
-            }
-            Term::RangeI(range) => {
-                let (lo, hi) = (range.start(), range.end());
-                quote! {
-                    p.range_i(#lo..=#hi)
                 }
             }
             Term::NegLookahead(term) => {