cl-ast: Remove Option-like "*Kind"s

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

@@ -93,13 +93,7 @@ pub trait Fold {
     }
     fn fold_module(&mut self, m: Module) -> Module {
         let Module { name, kind } = m;
-        Module { name: self.fold_sym(name), kind: self.fold_module_kind(kind) }
-    }
-    fn fold_module_kind(&mut self, m: ModuleKind) -> ModuleKind {
-        match m {
-            ModuleKind::Inline(f) => ModuleKind::Inline(self.fold_file(f)),
-            ModuleKind::Outline => ModuleKind::Outline,
-        }
+        Module { name: self.fold_sym(name), kind: kind.map(|v| self.fold_file(v)) }
     }
     fn fold_function(&mut self, f: Function) -> Function {
         let Function { name, sign, bind, body } = f;
@@ -136,11 +130,11 @@ pub trait Fold {
         }
     }
     fn fold_enum(&mut self, e: Enum) -> Enum {
-        let Enum { name, kind } = e;
-        Enum { name: self.fold_sym(name), kind: self.fold_enum_kind(kind) }
-    }
-    fn fold_enum_kind(&mut self, kind: EnumKind) -> EnumKind {
-        or_fold_enum_kind(self, kind)
+        let Enum { name, variants: kind } = e;
+        Enum {
+            name: self.fold_sym(name),
+            variants: kind.map(|v| v.into_iter().map(|v| self.fold_variant(v)).collect()),
+        }
     }
     fn fold_variant(&mut self, v: Variant) -> Variant {
         let Variant { name, kind } = v;
@@ -369,10 +363,7 @@ pub trait Fold {
     }
     fn fold_addrof(&mut self, a: AddrOf) -> AddrOf {
         let AddrOf { mutable, expr } = a;
-        AddrOf {
-            mutable: self.fold_mutability(mutable),
-            expr: Box::new(self.fold_expr(*expr)),
-        }
+        AddrOf { mutable: self.fold_mutability(mutable), expr: Box::new(self.fold_expr(*expr)) }
     }
     fn fold_block(&mut self, b: Block) -> Block {
         let Block { stmts } = b;
@@ -465,15 +456,6 @@ pub fn or_fold_item_kind<F: Fold + ?Sized>(folder: &mut F, kind: ItemKind) -> It
     }
 }
 
-#[inline]
-/// Folds a [ModuleKind] in the default way
-pub fn or_fold_module_kind<F: Fold + ?Sized>(folder: &mut F, kind: ModuleKind) -> ModuleKind {
-    match kind {
-        ModuleKind::Inline(f) => ModuleKind::Inline(folder.fold_file(f)),
-        ModuleKind::Outline => ModuleKind::Outline,
-    }
-}
-
 #[inline]
 /// Folds a [StructKind] in the default way
 pub fn or_fold_struct_kind<F: Fold + ?Sized>(folder: &mut F, kind: StructKind) -> StructKind {
@@ -490,17 +472,6 @@ pub fn or_fold_struct_kind<F: Fold + ?Sized>(folder: &mut F, kind: StructKind) -
     }
 }
 
-#[inline]
-/// Folds an [EnumKind] in the default way
-pub fn or_fold_enum_kind<F: Fold + ?Sized>(folder: &mut F, kind: EnumKind) -> EnumKind {
-    match kind {
-        EnumKind::NoVariants => EnumKind::NoVariants,
-        EnumKind::Variants(v) => {
-            EnumKind::Variants(v.into_iter().map(|v| folder.fold_variant(v)).collect())
-        }
-    }
-}
-
 #[inline]
 /// Folds a [VariantKind] in the default way
 pub fn or_fold_variant_kind<F: Fold + ?Sized>(folder: &mut F, kind: VariantKind) -> VariantKind {

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

@@ -74,10 +74,9 @@ pub trait Visit<'a>: Sized {
     fn visit_module(&mut self, m: &'a Module) {
         let Module { name, kind } = m;
         self.visit_sym(name);
-        self.visit_module_kind(kind);
-    }
-    fn visit_module_kind(&mut self, kind: &'a ModuleKind) {
-        or_visit_module_kind(self, kind)
+        if let Some(f) = kind {
+            self.visit_file(f)
+        }
     }
     fn visit_function(&mut self, f: &'a Function) {
         let Function { name, sign, bind, body } = f;
@@ -103,12 +102,11 @@ pub trait Visit<'a>: Sized {
         self.visit_ty(ty);
     }
     fn visit_enum(&mut self, e: &'a Enum) {
-        let Enum { name, kind } = e;
+        let Enum { name, variants: kind } = e;
         self.visit_sym(name);
-        self.visit_enum_kind(kind);
-    }
-    fn visit_enum_kind(&mut self, kind: &'a EnumKind) {
-        or_visit_enum_kind(self, kind)
+        if let Some(variants) = kind {
+            variants.iter().for_each(|v| self.visit_variant(v))
+        }
     }
     fn visit_variant(&mut self, v: &'a Variant) {
         let Variant { name, kind } = v;
@@ -406,13 +404,6 @@ pub fn or_visit_item_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a ItemKind)
     }
 }
 
-pub fn or_visit_module_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a ModuleKind) {
-    match kind {
-        ModuleKind::Inline(f) => visitor.visit_file(f),
-        ModuleKind::Outline => {}
-    }
-}
-
 pub fn or_visit_struct_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a StructKind) {
     match kind {
         StructKind::Empty => {}
@@ -421,13 +412,6 @@ pub fn or_visit_struct_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a StructK
     }
 }
 
-pub fn or_visit_enum_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a EnumKind) {
-    match kind {
-        EnumKind::NoVariants => {}
-        EnumKind::Variants(variants) => variants.iter().for_each(|v| visitor.visit_variant(v)),
-    }
-}
-
 pub fn or_visit_variant_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a VariantKind) {
     match kind {
         VariantKind::Plain => {}