move rest of parser

src/parser.rs

@@ -1,3 +1,4 @@
+pub mod declaration;
 pub mod error;
 pub mod expression;
 mod literals;
@@ -24,85 +25,13 @@ pub type IErr<I> = GreedyError<I, ErrorKind>;
 // custom IResult type for VerboseError
 pub type IResult<I, O, E = IErr<I>> = nom::IResult<I, O, E>;
 
+pub use crate::parser::declaration::{
+    assign_statement, declaration, typename, Assign, NetDecl, TypeName,
+};
 pub use crate::parser::expression::{expression, Call, Expression, Operation};
 pub use crate::parser::module::{module, Module, ModuleItem, PortDirection};
 use crate::parser::tokens::{token, TokenKind as tk, TokenSpan};
 
-fn ws0<'a, F: 'a, O, E: ParseError<Span<'a>>>(
-    inner: F,
-) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, O, E>
-where
-    F: FnMut(Span<'a>) -> IResult<Span<'a>, O, E>,
-{
-    delimited(multispace0, inner, multispace0)
-}
-
-fn identifier(input: Span) -> IResult<Span, Span> {
-    recognize(pair(
-        alt((alpha1, tag("_"))),
-        many0(alt((alphanumeric1, tag("_")))),
-    ))(input)
-}
-
-// TODO: allow recursive generics
-// TODO: allow expressions again
-fn typename(input: TokenSpan) -> IResult<TokenSpan, TypeName> {
-    map(
-        tuple((
-            token(tk::Ident),
-            opt(delimited(token(tk::LAngle), expression, token(tk::RAngle))),
-        )),
-        |(ident, _)| TypeName {
-            name: ident.span(),
-            generics: (),
-        },
-    )(input)
-}
-
-#[derive(Debug)]
-pub struct TypeName<'a> {
-    name: Span<'a>,
-    generics: (),
-}
-
-#[derive(Debug)]
-pub struct NetDecl<'a> {
-    pub name: Span<'a>,
-    pub typ: TypeName<'a>,
-    pub value: Option<Span<'a>>,
-}
-
-#[derive(Debug)]
-pub struct Assign<'a> {
-    pub lhs: &'a str,
-    pub expr: Expression<'a>,
-}
-
-fn assign_statement(input: TokenSpan) -> IResult<TokenSpan, Assign> {
-    map(
-        separated_pair(token(tk::Ident), token(tk::EqAssign), expression),
-        |(lhs, expr)| Assign {
-            lhs: (*lhs.span().fragment()),
-            expr,
-        },
-    )(input)
-}
-
-// TODO: reallow assignments
-fn declaration(i: TokenSpan) -> IResult<TokenSpan, NetDecl> {
-    map(
-        tuple((
-            separated_pair(token(tk::Ident), token(tk::Colon), typename),
-            opt(preceded(token(tk::Assign), token(tk::Number))),
-        )),
-        |((ident, typ), _value)| NetDecl {
-            name: ident.span(),
-            typ,
-            value: None,
-        },
-    )(i)
-}
-
 pub fn parse(input: TokenSpan) -> IResult<TokenSpan, Module> {
     module(input)
 }

src/parser/declaration.rs

@@ -0,0 +1,67 @@
+use nom::{
+    combinator::{map, opt},
+    sequence::{delimited, preceded, separated_pair, tuple},
+};
+
+use super::expression::{expression, Expression};
+use super::tokens::{token, TokenKind as tk, TokenSpan};
+use super::{IResult, Span};
+
+// TODO: allow recursive generics
+// TODO: allow expressions again
+pub fn typename(input: TokenSpan) -> IResult<TokenSpan, TypeName> {
+    map(
+        tuple((
+            token(tk::Ident),
+            opt(delimited(token(tk::LAngle), expression, token(tk::RAngle))),
+        )),
+        |(ident, _)| TypeName {
+            name: ident.span(),
+            generics: (),
+        },
+    )(input)
+}
+
+#[derive(Debug)]
+pub struct TypeName<'a> {
+    name: Span<'a>,
+    generics: (),
+}
+
+#[derive(Debug)]
+pub struct NetDecl<'a> {
+    pub name: Span<'a>,
+    pub typ: TypeName<'a>,
+    pub value: Option<Span<'a>>,
+}
+
+#[derive(Debug)]
+pub struct Assign<'a> {
+    pub lhs: &'a str,
+    pub expr: Expression<'a>,
+}
+
+pub fn assign_statement(input: TokenSpan) -> IResult<TokenSpan, Assign> {
+    map(
+        separated_pair(token(tk::Ident), token(tk::EqAssign), expression),
+        |(lhs, expr)| Assign {
+            lhs: (*lhs.span().fragment()),
+            expr,
+        },
+    )(input)
+}
+
+// TODO: reallow assignments
+pub fn declaration(i: TokenSpan) -> IResult<TokenSpan, NetDecl> {
+    map(
+        tuple((
+            separated_pair(token(tk::Ident), token(tk::Colon), typename),
+            opt(preceded(token(tk::Assign), token(tk::Number))),
+        )),
+        |((ident, typ), _value)| NetDecl {
+            name: ident.span(),
+            typ,
+            value: None,
+        },
+    )(i)
+}

src/parser/literals.rs

@@ -1,8 +1,11 @@
 use nom::{
-    character::complete::{char, one_of},
+    branch::alt,
+    bytes::complete::tag,
+    character::complete::{alpha1, alphanumeric1, char, multispace0, one_of},
     combinator::{map, recognize},
+    error::ParseError,
     multi::{many0, many1},
-    sequence::{preceded, terminated},
+    sequence::{delimited, pair, preceded, terminated},
 };
 
 use crate::parser::{IResult, Span};
@@ -23,6 +26,22 @@ pub fn hexadecimal(input: Span) -> IResult<Span, u64> {
     )(input)
 }
 
+pub fn ws0<'a, F: 'a, O, E: ParseError<Span<'a>>>(
+    inner: F,
+) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, O, E>
+where
+    F: FnMut(Span<'a>) -> IResult<Span<'a>, O, E>,
+{
+    delimited(multispace0, inner, multispace0)
+}
+
+pub fn identifier(input: Span) -> IResult<Span, Span> {
+    recognize(pair(
+        alt((alpha1, tag("_"))),
+        many0(alt((alphanumeric1, tag("_")))),
+    ))(input)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

src/parser/tokens.rs

@@ -1,6 +1,9 @@
 //! convert text into a token stream
 
-use super::{identifier, ws0, IResult, Span};
+use super::{
+    literals::{identifier, ws0},
+    IResult, Span,
+};
 use nom::{
     branch::alt,
     bytes::complete::tag,