cl-ast: Remove variantkind, as it was redundant

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -143,16 +143,17 @@ pub trait Fold {
         Enum {
             name: self.fold_sym(name),
             gens: self.fold_generics(gens),
-            variants: kind.map(|v| v.into_iter().map(|v| self.fold_variant(v)).collect()),
+            variants: kind.into_iter().map(|v| self.fold_variant(v)).collect(),
         }
     }
     fn fold_variant(&mut self, v: Variant) -> Variant {
-        let Variant { name, kind } = v;
+        let Variant { name, kind, body } = v;
 
-        Variant { name: self.fold_sym(name), kind: self.fold_variant_kind(kind) }
-    }
-    fn fold_variant_kind(&mut self, kind: VariantKind) -> VariantKind {
-        or_fold_variant_kind(self, kind)
+        Variant {
+            name: self.fold_sym(name),
+            kind: self.fold_struct_kind(kind),
+            body: body.map(|e| Box::new(self.fold_expr(*e))),
+        }
     }
     fn fold_impl(&mut self, i: Impl) -> Impl {
         let Impl { target, body } = i;
@@ -486,21 +487,6 @@ pub fn or_fold_struct_kind<F: Fold + ?Sized>(folder: &mut F, kind: StructKind) -
     }
 }
 
-#[inline]
-/// Folds a [VariantKind] in the default way
-pub fn or_fold_variant_kind<F: Fold + ?Sized>(folder: &mut F, kind: VariantKind) -> VariantKind {
-    match kind {
-        VariantKind::Plain => VariantKind::Plain,
-        VariantKind::CLike(n) => VariantKind::CLike(n),
-        VariantKind::Tuple(t) => VariantKind::Tuple(folder.fold_ty(t)),
-        VariantKind::Struct(mem) => VariantKind::Struct(
-            mem.into_iter()
-                .map(|m| folder.fold_struct_member(m))
-                .collect(),
-        ),
-    }
-}
-
 #[inline]
 /// Folds an [ImplKind] in the default way
 pub fn or_fold_impl_kind<F: Fold + ?Sized>(folder: &mut F, kind: ImplKind) -> ImplKind {

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -106,9 +106,6 @@ pub trait Visit<'a>: Sized {
     fn visit_variant(&mut self, value: &'a Variant) {
         value.children(self)
     }
-    fn visit_variant_kind(&mut self, value: &'a VariantKind) {
-        value.children(self)
-    }
     fn visit_impl(&mut self, value: &'a Impl) {
         value.children(self)
     }

compiler/cl-ast/src/ast_visitor/walk.rs

@@ -276,9 +276,7 @@ impl Walk for Enum {
         let Enum { name, gens, variants } = self;
         name.visit_in(v);
         gens.visit_in(v);
-        if let Some(variants) = variants {
-            variants.visit_in(v);
-        }
+        variants.visit_in(v);
     }
 }
 impl Walk for Variant {
@@ -287,23 +285,10 @@ impl Walk for Variant {
         v.visit_variant(self);
     }
     fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
-        let Variant { name, kind } = self;
+        let Variant { name, kind, body } = self;
         name.visit_in(v);
         kind.visit_in(v);
-    }
-}
-impl Walk for VariantKind {
-    #[inline]
-    fn visit_in<'a, V: Visit<'a>>(&'a self, v: &mut V) {
-        v.visit_variant_kind(self);
-    }
-    fn children<'a, V: Visit<'a>>(&'a self, v: &mut V) {
-        match self {
-            VariantKind::Plain => {}
-            VariantKind::CLike(_) => {}
-            VariantKind::Tuple(t) => t.visit_in(v),
-            VariantKind::Struct(m) => m.visit_in(v),
-        }
+        body.visit_in(v);
     }
 }
 impl Walk for Impl {