feat: visitor pattern for vimdoc (#74)

Author: numToStr

src/lib.rs

@@ -8,10 +8,35 @@ use std::{fmt::Display, str::FromStr};
 
 use chumsky::prelude::Simple;
 
-use parser::Node;
+use parser::{
+    Alias, Brief, Class, Divider, Field, Func, Module, Node, Param, Return, See, Tag, Type, Usage,
+};
 
 use crate::lexer::TagType;
 
+pub trait Visitor {
+    type R;
+    type S;
+    fn module(&self, n: &Module, s: &Self::S) -> Self::R;
+    fn divider(&self, n: &Divider, s: &Self::S) -> Self::R;
+    fn brief(&self, n: &Brief, s: &Self::S) -> Self::R;
+    fn tag(&self, n: &Tag, s: &Self::S) -> Self::R;
+    fn func(&self, n: &Func, s: &Self::S) -> Self::R;
+    fn params(&self, n: &[Param], s: &Self::S) -> Self::R;
+    fn r#returns(&self, n: &[Return], s: &Self::S) -> Self::R;
+    fn class(&self, n: &Class, s: &Self::S) -> Self::R;
+    fn fields(&self, n: &[Field], s: &Self::S) -> Self::R;
+    fn alias(&self, n: &Alias, s: &Self::S) -> Self::R;
+    fn r#type(&self, n: &Type, s: &Self::S) -> Self::R;
+    fn toc(&self, n: &str, nodes: &[Node], s: &Self::S) -> Self::R;
+    fn see(&self, n: &See, s: &Self::S) -> Self::R;
+    fn usage(&self, n: &Usage, s: &Self::S) -> Self::R;
+}
+
+pub trait Accept<T: Visitor> {
+    fn accept(&self, n: &T, s: &T::S) -> T::R;
+}
+
 pub trait Nodes {
     fn nodes(&self) -> &Vec<Node>;
 }

src/parser/node.rs

@@ -6,6 +6,7 @@ use chumsky::{
 use crate::{
     lexer::{Lexer, TagType},
     parser::{Alias, Brief, Class, Divider, Func, Module, Tag, Type},
+    Accept, Visitor,
 };
 
 use super::impl_parse;
@@ -44,6 +45,22 @@ impl_parse!(Node, Option<Self>, {
     .or(any().to(None))
 });
 
+impl<T: Visitor> Accept<T> for Node {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        match self {
+            Self::Brief(x) => x.accept(n, s),
+            Self::Tag(x) => x.accept(n, s),
+            Self::Alias(x) => x.accept(n, s),
+            Self::Func(x) => x.accept(n, s),
+            Self::Class(x) => x.accept(n, s),
+            Self::Type(x) => x.accept(n, s),
+            Self::Module(x) => x.accept(n, s),
+            Self::Divider(x) => x.accept(n, s),
+            _ => unimplemented!(),
+        }
+    }
+}
+
 impl Node {
     fn init() -> impl Parser<TagType, Vec<Node>, Error = Simple<TagType>> {
         Node::parse().repeated().flatten()

src/parser/tags/alias.rs

@@ -3,6 +3,7 @@ use chumsky::{prelude::choice, select, Parser};
 use crate::{
     lexer::{Member, TagType, Ty},
     parser::{impl_parse, Prefix},
+    Accept, Visitor,
 };
 
 #[derive(Debug, Clone)]
@@ -43,3 +44,9 @@ impl_parse!(Alias, {
         prefix: Prefix::default(),
     })
 });
+
+impl<T: Visitor> Accept<T> for Alias {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.alias(self, s)
+    }
+}

src/parser/tags/brief.rs

@@ -1,6 +1,6 @@
 use chumsky::{prelude::just, select, Parser};
 
-use crate::{lexer::TagType, parser::impl_parse};
+use crate::{lexer::TagType, parser::impl_parse, Accept, Visitor};
 
 #[derive(Debug, Clone)]
 pub struct Brief {
@@ -15,3 +15,9 @@ impl_parse!(Brief, {
     .delimited_by(just(TagType::BriefStart), just(TagType::BriefEnd))
     .map(|desc| Self { desc })
 });
+
+impl<T: Visitor> Accept<T> for Brief {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.brief(self, s)
+    }
+}

src/parser/tags/class.rs

@@ -3,6 +3,7 @@ use chumsky::{select, Parser};
 use crate::{
     lexer::{Name, Scope, TagType, Ty},
     parser::{impl_parse, Prefix, See},
+    Accept, Visitor,
 };
 
 #[derive(Debug, Clone)]
@@ -66,3 +67,9 @@ impl_parse!(Class, {
             prefix: Prefix::default(),
         })
 });
+
+impl<T: Visitor> Accept<T> for Class {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.class(self, s)
+    }
+}

src/parser/tags/divider.rs

@@ -1,10 +1,16 @@
 use chumsky::select;
 
-use crate::{lexer::TagType, parser::impl_parse};
+use crate::{lexer::TagType, parser::impl_parse, Accept, Visitor};
 
 #[derive(Debug, Clone)]
 pub struct Divider(pub char);
 
 impl_parse!(Divider, {
     select! { TagType::Divider(rune) => Self(rune) }
 });
+
+impl<T: Visitor> Accept<T> for Divider {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.divider(self, s)
+    }
+}

src/parser/tags/func.rs

@@ -3,6 +3,7 @@ use chumsky::{select, Parser};
 use crate::{
     lexer::{Name, Op, TagType, Ty},
     parser::{impl_parse, Prefix, See},
+    Accept, Visitor,
 };
 
 use super::Usage;
@@ -96,3 +97,9 @@ impl_parse!(Func, {
         },
     )
 });
+
+impl<T: Visitor> Accept<T> for Func {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.func(self, s)
+    }
+}

src/parser/tags/module.rs

@@ -1,6 +1,6 @@
 use chumsky::select;
 
-use crate::{lexer::TagType, parser::impl_parse};
+use crate::{lexer::TagType, parser::impl_parse, Accept, Visitor};
 
 #[derive(Debug, Clone)]
 pub struct Module {
@@ -11,3 +11,9 @@ pub struct Module {
 impl_parse!(Module, {
     select! { TagType::Module(name, desc) => Self { name, desc } }
 });
+
+impl<T: Visitor> Accept<T> for Module {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.module(self, s)
+    }
+}

src/parser/tags/see.rs

@@ -1,6 +1,6 @@
 use chumsky::{select, Parser};
 
-use crate::{lexer::TagType, parser::impl_parse};
+use crate::{lexer::TagType, parser::impl_parse, Accept, Visitor};
 
 #[derive(Debug, Clone)]
 pub struct See {
@@ -12,3 +12,9 @@ impl_parse!(See, {
         .repeated()
         .map(|refs| Self { refs })
 });
+
+impl<T: Visitor> Accept<T> for See {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.see(self, s)
+    }
+}

src/parser/tags/tag.rs

@@ -1,10 +1,16 @@
 use chumsky::select;
 
-use crate::{lexer::TagType, parser::impl_parse};
+use crate::{lexer::TagType, parser::impl_parse, Accept, Visitor};
 
 #[derive(Debug, Clone)]
 pub struct Tag(pub String);
 
 impl_parse!(Tag, {
     select! { TagType::Tag(x) => Self(x) }
 });
+
+impl<T: Visitor> Accept<T> for Tag {
+    fn accept(&self, n: &T, s: &T::S) -> T::R {
+        n.tag(self, s)
+    }
+}