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

compiler/cl-parser/src/inliner.rs

@@ -48,15 +48,15 @@ impl ModuleInliner {
     }
 
     /// Records an [I/O error](std::io::Error) for later
-    fn handle_io_error(&mut self, error: std::io::Error) -> ModuleKind {
+    fn handle_io_error(&mut self, error: std::io::Error) -> Option<File> {
         self.io_errs.push((self.path.clone(), error));
-        ModuleKind::Outline
+        None
     }
 
     /// Records a [parse error](crate::error::Error) for later
-    fn handle_parse_error(&mut self, error: crate::error::Error) -> ModuleKind {
+    fn handle_parse_error(&mut self, error: crate::error::Error) -> Option<File> {
         self.parse_errs.push((self.path.clone(), error));
-        ModuleKind::Outline
+        None
     }
 }
 
@@ -71,11 +71,13 @@ impl Fold for ModuleInliner {
         self.path.pop(); // cd ..
         Module { name, kind }
     }
+}
 
+impl ModuleInliner {
     /// Attempts to read and parse a file for every module in the tree
-    fn fold_module_kind(&mut self, m: ModuleKind) -> ModuleKind {
-        if let ModuleKind::Inline(f) = m {
-            return ModuleKind::Inline(self.fold_file(f));
+    fn fold_module_kind(&mut self, m: Option<File>) -> Option<File> {
+        if let Some(f) = m {
+            return Some(self.fold_file(f));
         }
         // cd path/mod.cl
         self.path.set_extension("cl");
@@ -105,7 +107,7 @@ impl Fold for ModuleInliner {
             Ok(file) => {
                 self.path.set_extension("");
                 // The newly loaded module may need further inlining
-                ModuleKind::Inline(self.fold_file(file))
+                Some(self.fold_file(file))
             }
         }
     }

compiler/cl-parser/src/parser.rs

@@ -414,24 +414,22 @@ impl Parse<'_> for Module {
     fn parse(p: &mut Parser<'_>) -> PResult<Self> {
         p.consume_peeked();
 
-        Ok(Module { name: Sym::parse(p)?, kind: ModuleKind::parse(p)? })
-    }
-}
+        Ok(Module {
+            name: Sym::parse(p)?,
+            kind: {
+                const P: Parsing = Parsing::ModuleKind;
+                let inline = delim(Parse::parse, CURLIES, P);
 
-impl Parse<'_> for ModuleKind {
-    /// Parses the item list associated with a [Module], if present
-    fn parse(p: &mut Parser) -> PResult<ModuleKind> {
-        const P: Parsing = Parsing::ModuleKind;
-        let inline = delim(Parse::parse, CURLIES, P);
-
-        match p.peek_kind(P)? {
-            TokenKind::LCurly => Ok(ModuleKind::Inline(inline(p)?)),
-            TokenKind::Semi => {
-                p.consume_peeked();
-                Ok(ModuleKind::Outline)
-            }
-            got => Err(p.error(ExpectedToken { want: TokenKind::Semi, got }, P)),
-        }
+                match p.peek_kind(P)? {
+                    TokenKind::LCurly => Some(inline(p)?),
+                    TokenKind::Semi => {
+                        p.consume_peeked();
+                        None
+                    }
+                    got => Err(p.error(ExpectedToken { want: TokenKind::Semi, got }, P))?,
+                }
+            },
+        })
     }
 }
 
@@ -555,26 +553,23 @@ impl Parse<'_> for Enum {
     /// Parses an [`enum`](Enum) definition
     fn parse(p: &mut Parser) -> PResult<Enum> {
         p.match_type(TokenKind::Enum, Parsing::Enum)?;
-
-        Ok(Enum { name: Sym::parse(p)?, kind: EnumKind::parse(p)? })
-    }
-}
-
-impl Parse<'_> for EnumKind {
-    /// Parses the various [kinds of Enum](EnumKind)
-    fn parse(p: &mut Parser<'_>) -> PResult<EnumKind> {
-        const P: Parsing = Parsing::EnumKind;
-        Ok(match p.peek_kind(P)? {
-            TokenKind::LCurly => EnumKind::Variants(delim(
-                sep(Variant::parse, TokenKind::Comma, TokenKind::RCurly, P),
-                CURLIES,
-                P,
-            )(p)?),
-            TokenKind::Semi => {
-                p.consume_peeked();
-                EnumKind::NoVariants
-            }
-            t => Err(p.error(Unexpected(t), P))?,
+        Ok(Enum {
+            name: Sym::parse(p)?,
+            variants: {
+                const P: Parsing = Parsing::EnumKind;
+                match p.peek_kind(P)? {
+                    TokenKind::LCurly => Some(delim(
+                        sep(Variant::parse, TokenKind::Comma, TokenKind::RCurly, P),
+                        CURLIES,
+                        P,
+                    )(p)?),
+                    TokenKind::Semi => {
+                        p.consume_peeked();
+                        None
+                    }
+                    t => Err(p.error(Unexpected(t), P))?,
+                }
+            },
         })
     }
 }