cl-ast: Remove variantkind, as it was redundant

compiler/cl-typeck/src/stage/categorize.rs

@@ -106,27 +106,29 @@ fn cat_enum<'a>(_table: &mut Table<'a>, _node: Handle, e: &'a Enum) -> CatResult
 }
 
 fn cat_variant<'a>(table: &mut Table<'a>, node: Handle, v: &'a Variant) -> CatResult<()> {
-    let Variant { name, kind } = v;
+    let Variant { name, kind, body } = v;
     let parent = table.parent(node).copied().unwrap_or(table.root());
     table.add_child(parent, *name, node);
-    match kind {
-        VariantKind::Plain => {
-            table.set_ty(node, TypeKind::Instance(parent));
+    match (kind, body) {
+        (StructKind::Empty, None) => {
+            table.set_ty(node, TypeKind::Adt(Adt::UnitStruct));
             Ok(())
         }
-        VariantKind::CLike(c) => {
+        (StructKind::Empty, Some(c)) => {
             table.set_body(node, c);
-            table.set_ty(node, TypeKind::Instance(parent));
+            table.set_ty(node, TypeKind::Adt(Adt::UnitStruct));
             Ok(())
         }
-        VariantKind::Tuple(ty) => {
-            let ty = ty
-                .evaluate(table, node)
-                .map_err(|e| Error::TypeEval(e, " while categorizing a variant"))?;
-            table.set_ty(node, TypeKind::Instance(ty));
+        (StructKind::Tuple(ty), None) => {
+            let ty = TypeKind::Adt(Adt::TupleStruct(
+                ty.iter()
+                    .map(|ty| ty.evaluate(table, node).map(|ty| (Visibility::Public, ty)))
+                    .collect::<Result<_, _>>()?,
+            ));
+            table.set_ty(node, ty);
             Ok(())
         }
-        VariantKind::Struct(members) => {
+        (StructKind::Struct(members), None) => {
             let mut out = vec![];
             for StructMember { vis, name, ty } in members {
                 let ty = ty.evaluate(table, node)?;
@@ -144,6 +146,9 @@ fn cat_variant<'a>(table: &mut Table<'a>, node: Handle, v: &'a Variant) -> CatRe
             table.set_ty(node, TypeKind::Adt(Adt::Struct(out)));
             Ok(())
         }
+        (_, Some(body)) => {
+            panic!("Unexpected body `{body}` in enum variant `{v}`")
+        }
     }
 }
 

compiler/cl-typeck/src/stage/populate.rs

@@ -4,7 +4,7 @@ use crate::{
     handle::Handle,
     source::Source,
     table::{NodeKind, Table},
-    type_kind::{Primitive, TypeKind},
+    type_kind::TypeKind,
 };
 use cl_ast::{
     ItemKind, Sym,
@@ -145,7 +145,7 @@ impl<'a> Visit<'a> for Populator<'_, 'a> {
         self.visit(gens);
         self.visit(variants);
         let mut children = Vec::new();
-        for variant in variants.iter().flatten() {
+        for variant in variants.iter() {
             let mut entry = self.new_entry(NodeKind::Type);
             variant.visit_in(&mut entry);
             children.push((variant.name, entry.inner.id()));
@@ -155,27 +155,18 @@ impl<'a> Visit<'a> for Populator<'_, 'a> {
     }
 
     fn visit_variant(&mut self, value: &'a cl_ast::Variant) {
-        let cl_ast::Variant { name, kind } = value;
+        let cl_ast::Variant { name, kind, body } = value;
         let mut entry = self.new_entry(NodeKind::Type);
         entry.inner.set_source(Source::Variant(value));
         entry.visit(kind);
+        if let Some(body) = body {
+            entry.inner.set_body(body);
+        }
 
         let child = entry.inner.id();
         self.inner.add_child(*name, child);
     }
 
-    fn visit_variant_kind(&mut self, value: &'a cl_ast::VariantKind) {
-        match value {
-            cl_ast::VariantKind::Plain => self.inner.set_ty(TypeKind::Empty),
-            cl_ast::VariantKind::CLike(body) => {
-                self.inner.set_body(body);
-                self.inner.set_ty(TypeKind::Primitive(Primitive::Integer))
-            }
-            cl_ast::VariantKind::Tuple(_) => None,
-            cl_ast::VariantKind::Struct(_) => None,
-        };
-    }
-
     fn visit_impl(&mut self, i: &'a cl_ast::Impl) {
         let cl_ast::Impl { target, body } = i;
         self.inner.set_source(Source::Impl(i));