syntax: simplify hir::GroupKind

I'm not sure exactly why I used three variants instead of two like how
I've defined it in this patch. Possibly because the AST uses three
variants? (The AST needs to do a little more work to store a span
associated with where the name actually is in the expression, so it
maybe makes a little more sense there.)

In any case, this is the first step of many in simplifying the HIR.

Author: BurntSushi

regex-syntax/src/hir/mod.rs

@@ -1383,19 +1383,17 @@ pub struct Group {
 /// The kind of group.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum GroupKind {
-    /// A normal unnamed capturing group.
+    /// A non-capturing group.
+    NonCapturing,
+    /// A capturing group with an optional name.
     ///
     /// The value is the capture index of the group.
-    CaptureIndex(u32),
-    /// A named capturing group.
-    CaptureName {
-        /// The name of the group.
-        name: String,
+    Capture {
         /// The capture index of the group.
         index: u32,
+        /// The name of the group, if it exists.
+        name: Option<String>,
     },
-    /// A non-capturing group.
-    NonCapturing,
 }
 
 /// The high-level intermediate representation of a repetition operator.

regex-syntax/src/hir/print.rs

@@ -150,11 +150,11 @@ impl<W: fmt::Write> Visitor for Writer<W> {
                 self.wtr.write_str(r"(?-u:\B)")?;
             }
             HirKind::Group(ref x) => match x.kind {
-                hir::GroupKind::CaptureIndex(_) => {
+                hir::GroupKind::Capture { ref name, .. } => {
                     self.wtr.write_str("(")?;
-                }
-                hir::GroupKind::CaptureName { ref name, .. } => {
-                    write!(self.wtr, "(?P<{}>", name)?;
+                    if let Some(ref name) = *name {
+                        write!(self.wtr, "?P<{}>", name)?;
+                    }
                 }
                 hir::GroupKind::NonCapturing => {
                     self.wtr.write_str("(?:")?;

regex-syntax/src/hir/translate.rs

@@ -763,15 +763,13 @@ impl<'t, 'p> TranslatorI<'t, 'p> {
 
     fn hir_group(&self, group: &ast::Group, expr: Hir) -> Hir {
         let kind = match group.kind {
-            ast::GroupKind::CaptureIndex(idx) => {
-                hir::GroupKind::CaptureIndex(idx)
-            }
-            ast::GroupKind::CaptureName(ref capname) => {
-                hir::GroupKind::CaptureName {
-                    name: capname.name.clone(),
-                    index: capname.index,
-                }
+            ast::GroupKind::CaptureIndex(index) => {
+                hir::GroupKind::Capture { index, name: None }
             }
+            ast::GroupKind::CaptureName(ref cap) => hir::GroupKind::Capture {
+                index: cap.index,
+                name: Some(cap.name.clone()),
+            },
             ast::GroupKind::NonCapturing(_) => hir::GroupKind::NonCapturing,
         };
         Hir::group(hir::Group { kind, hir: Box::new(expr) })
@@ -1211,16 +1209,16 @@ mod tests {
 
     fn hir_group(i: u32, expr: Hir) -> Hir {
         Hir::group(hir::Group {
-            kind: hir::GroupKind::CaptureIndex(i),
+            kind: hir::GroupKind::Capture { index: i, name: None },
             hir: Box::new(expr),
         })
     }
 
     fn hir_group_name(i: u32, name: &str, expr: Hir) -> Hir {
         Hir::group(hir::Group {
-            kind: hir::GroupKind::CaptureName {
-                name: name.to_string(),
+            kind: hir::GroupKind::Capture {
                 index: i,
+                name: Some(name.to_string()),
             },
             hir: Box::new(expr),
         })

src/compile.rs

@@ -362,17 +362,13 @@ impl Compiler {
             }
             Group(ref g) => match g.kind {
                 hir::GroupKind::NonCapturing => self.c(&g.hir),
-                hir::GroupKind::CaptureIndex(index) => {
+                hir::GroupKind::Capture { index, ref name } => {
                     if index as usize >= self.compiled.captures.len() {
-                        self.compiled.captures.push(None);
-                    }
-                    self.c_capture(2 * index as usize, &g.hir)
-                }
-                hir::GroupKind::CaptureName { index, ref name } => {
-                    if index as usize >= self.compiled.captures.len() {
-                        let n = name.to_string();
-                        self.compiled.captures.push(Some(n.clone()));
-                        self.capture_name_idx.insert(n, index as usize);
+                        self.compiled.captures.push(name.clone());
+                        if let Some(ref name) = *name {
+                            self.capture_name_idx
+                                .insert(name.clone(), index as usize);
+                        }
                     }
                     self.c_capture(2 * index as usize, &g.hir)
                 }