cl-ast: Remove variantkind, as it was redundant

compiler/cl-ast/src/ast.rs

@@ -169,23 +169,15 @@ pub struct StructMember {
 pub struct Enum {
     pub name: Sym,
     pub gens: Generics,
-    pub variants: Option<Vec<Variant>>,
+    pub variants: Vec<Variant>,
 }
 
 /// A single [Enum] variant
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Variant {
     pub name: Sym,
-    pub kind: VariantKind,
-}
-
-/// Whether the [Variant] has a C-like constant value, a tuple, or [StructMember]s
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum VariantKind {
-    Plain,
-    CLike(Box<Expr>),
-    Tuple(Ty),
-    Struct(Vec<StructMember>),
+    pub kind: StructKind,
+    pub body: Option<Box<Expr>>,
 }
 
 /// Sub-[items](Item) (associated functions, etc.) for a [Ty]

compiler/cl-ast/src/ast_impl/convert.rs

@@ -39,10 +39,6 @@ impl_from! {
         Vec<Ty> => StructKind::Tuple,
         // TODO: Struct members in struct
     }
-    impl From for VariantKind {
-        Ty => VariantKind::Tuple,
-        // TODO: enum struct variants
-    }
     impl From for TyKind {
         Path => TyKind::Path,
         TyTuple => TyKind::Tuple,

compiler/cl-ast/src/ast_impl/display.rs

@@ -227,29 +227,19 @@ impl Display for StructMember {
 
 impl Display for Enum {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { name, gens, variants: kind } = self;
+        let Self { name, gens, variants } = self;
         write!(f, "enum {name}{gens}")?;
-        match kind {
-            Some(v) => separate(v, ",\n")(f.delimit(SPACED_BRACES)),
-            None => ";".fmt(f),
-        }
+        separate(variants, ",\n")(f.delimit(SPACED_BRACES))
     }
 }
 
 impl Display for Variant {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { name, kind } = self;
-        write!(f, "{name}{kind}")
-    }
-}
-
-impl Display for VariantKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            VariantKind::Plain => Ok(()),
-            VariantKind::CLike(n) => write!(f, " = {n}"),
-            VariantKind::Tuple(v) => v.fmt(f),
-            VariantKind::Struct(v) => separate(v, ", ")(f.delimit(INLINE_BRACES)),
+        let Self { name, kind, body } = self;
+        write!(f, "{name}{kind}")?;
+        match body {
+            Some(body) => write!(f, " {body}"),
+            None => Ok(()),
         }
     }
 }

compiler/cl-ast/src/ast_impl/weight_of.rs

@@ -134,29 +134,14 @@ impl WeightOf for StructMember {
 impl WeightOf for Enum {
     fn weight_of(&self) -> usize {
         let Self { name, gens, variants } = self;
-        name.weight_of()
-            + gens.weight_of()
-            + variants
-                .as_ref()
-                .map_or(size_of_val(variants), |v| v.weight_of())
+        name.weight_of() + gens.weight_of() + variants.weight_of()
     }
 }
 
 impl WeightOf for Variant {
     fn weight_of(&self) -> usize {
-        let Self { name, kind } = self;
-        name.weight_of() + kind.weight_of()
-    }
-}
-
-impl WeightOf for VariantKind {
-    fn weight_of(&self) -> usize {
-        match self {
-            VariantKind::Plain => size_of_val(self),
-            VariantKind::CLike(v) => v.weight_of(),
-            VariantKind::Tuple(ty) => ty.weight_of(),
-            VariantKind::Struct(m) => m.weight_of(),
-        }
+        let Self { name, kind, body } = self;
+        name.weight_of() + kind.weight_of() + body.weight_of()
     }
 }
 
@@ -559,7 +544,7 @@ impl WeightOf for Return {
 impl<T: WeightOf> WeightOf for Option<T> {
     fn weight_of(&self) -> usize {
         match self {
-            Some(t) => t.weight_of(),
+            Some(t) => t.weight_of().max(size_of_val(t)),
             None => size_of_val(self),
         }
     }

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 {