refactor(xatu): clarify parser conversions

src/xatu/parser.rs

@@ -61,10 +61,11 @@ fn convert_node(node: rnix::SyntaxNode) -> Option<ast::Node> {
 fn convert_apply(node: rnix::SyntaxNode) -> Option<ast::Node> {
     let apply = rnix::ast::Apply::cast(node)?;
     let range = apply.syntax().text_range().into();
+    let data = convert_apply_data(apply)?;
 
     Some(ast::Node {
         range,
-        data: ast::NodeData::Apply(apply.try_into().ok()?),
+        data: ast::NodeData::Apply(data),
     })
 }
 
@@ -73,10 +74,52 @@ fn convert_inherit(node: rnix::SyntaxNode) -> Option<ast::Node> {
 
     Some(ast::Node {
         range: inherit.syntax().text_range().into(),
-        data: ast::NodeData::Inherit(inherit.into()),
+        data: ast::NodeData::Inherit(convert_inherit_data(inherit)),
     })
 }
 
+fn convert_apply_data(apply: rnix::ast::Apply) -> Option<ast::Apply> {
+    Some(ast::Apply {
+        function: convert_expr(apply.lambda()?)?,
+    })
+}
+
+fn convert_expr(expr: rnix::ast::Expr) -> Option<ast::Expr> {
+    match expr {
+        rnix::ast::Expr::Ident(ident) => Some(ast::Expr::Ident(convert_ident(ident)?)),
+        rnix::ast::Expr::Select(select) => {
+            Some(ast::Expr::Select(Box::new(convert_select(select)?)))
+        }
+        _ => None,
+    }
+}
+
+fn convert_ident(ident: rnix::ast::Ident) -> Option<ast::Ident> {
+    Some(ast::Ident {
+        name: ident.ident_token()?.text().to_owned(),
+    })
+}
+
+fn convert_select(select: rnix::ast::Select) -> Option<ast::Select> {
+    Some(ast::Select {
+        receiver: convert_expr(select.expr()?)?,
+        attrs: select
+            .attrpath()?
+            .attrs()
+            .map(|attr| match attr {
+                rnix::ast::Attr::Ident(ident) => convert_ident(ident),
+                _ => None,
+            })
+            .collect::<Option<Vec<_>>>()?,
+    })
+}
+
+fn convert_inherit_data(inherit: rnix::ast::Inherit) -> ast::Inherit {
+    ast::Inherit {
+        attr_count: inherit.attrs().count(),
+    }
+}
+
 impl From<rnix::TextRange> for ast::SourceRange {
     fn from(range: rnix::TextRange) -> Self {
         Self {
@@ -85,62 +128,3 @@ impl From<rnix::TextRange> for ast::SourceRange {
         }
     }
 }
-
-impl TryFrom<rnix::ast::Apply> for ast::Apply {
-    type Error = ();
-
-    fn try_from(apply: rnix::ast::Apply) -> Result<Self, Self::Error> {
-        Ok(Self {
-            function: apply.lambda().ok_or(())?.try_into()?,
-        })
-    }
-}
-
-impl TryFrom<rnix::ast::Expr> for ast::Expr {
-    type Error = ();
-
-    fn try_from(expr: rnix::ast::Expr) -> Result<Self, Self::Error> {
-        match expr {
-            rnix::ast::Expr::Ident(ident) => Ok(Self::Ident(ident.try_into()?)),
-            rnix::ast::Expr::Select(select) => Ok(Self::Select(Box::new(select.try_into()?))),
-            _ => Err(()),
-        }
-    }
-}
-
-impl TryFrom<rnix::ast::Ident> for ast::Ident {
-    type Error = ();
-
-    fn try_from(ident: rnix::ast::Ident) -> Result<Self, Self::Error> {
-        Ok(Self {
-            name: ident.ident_token().ok_or(())?.text().to_owned(),
-        })
-    }
-}
-
-impl TryFrom<rnix::ast::Select> for ast::Select {
-    type Error = ();
-
-    fn try_from(select: rnix::ast::Select) -> Result<Self, Self::Error> {
-        Ok(Self {
-            receiver: select.expr().ok_or(())?.try_into()?,
-            attrs: select
-                .attrpath()
-                .ok_or(())?
-                .attrs()
-                .map(|attr| match attr {
-                    rnix::ast::Attr::Ident(ident) => ident.try_into(),
-                    _ => Err(()),
-                })
-                .collect::<Result<Vec<_>, _>>()?,
-        })
-    }
-}
-
-impl From<rnix::ast::Inherit> for ast::Inherit {
-    fn from(inherit: rnix::ast::Inherit) -> Self {
-        Self {
-            attr_count: inherit.attrs().count(),
-        }
-    }
-}