feat: support deep access

Author: numToStr

src/lexer.rs

@@ -265,22 +265,45 @@ impl Lexer {
         let ret = keyword("return");
         let assign = just('=').padded();
 
+        // obj = ID (prop)+ "="
+        // fn = ID (prop | colon_op)
+        // prop = (dot_op)+ ("(" | colon_op)
+        // dot_op = "." ID
+        // colon_op = ":" ID "("
+        let colon_op = just(':')
+            .ignore_then(ident())
+            .then_ignore(just('('))
+            .map(Op::Colon);
+
+        let dot_op = just('.')
+            .ignore_then(ident().map(Op::Dot))
+            .repeated()
+            .at_least(1);
+
+        let prop = dot_op
+            .then(choice((just('(').to(None), colon_op.map(Some))))
+            .map(|(mut props, meth)| {
+                if let Some(x) = meth {
+                    props.push(x)
+                }
+                Op::Deep(props)
+            });
+
         let dotted = ident()
-            .then(choice((just('.').to(Kind::Dot), just(':').to(Kind::Colon))))
-            .then(ident())
-            .map(|((prefix, scope), name)| (Some(prefix), scope, name));
+            .then(choice((prop, colon_op)))
+            .map(|(prefix, op)| (prefix, op));
 
-        let expr = dotted.clone().then_ignore(assign);
+        let expr = ident().then(dot_op).then_ignore(assign);
 
         choice((
             triple.ignore_then(choice((tag, variant, comment.map(TagType::Comment)))),
             func.clone()
                 .ignore_then(dotted)
-                .map(|(prefix, kind, name)| TagType::Func { prefix, name, kind }),
+                .map(|(prefix, op)| TagType::Func(prefix, op)),
             expr.then(func.or_not())
-                .map(|((prefix, kind, name), is_func)| match is_func {
-                    Some(_) => TagType::Func { prefix, name, kind },
-                    None => TagType::Expr { prefix, name, kind },
+                .map(|((prefix, op), is_fn)| match is_fn {
+                    Some(_) => TagType::Func(prefix, Op::Deep(op)),
+                    None => TagType::Expr(prefix, Op::Deep(op)),
                 }),
             ret.ignore_then(ident().padded())
                 .then_ignore(end())

src/lexer/token.rs

@@ -18,20 +18,12 @@ pub enum TagType {
     /// function one.two() end
     /// one.two = function() end
     /// ```
-    Func {
-        prefix: Option<String>,
-        name: String,
-        kind: Kind,
-    },
+    Func(String, Op),
     /// ```lua
     /// one = 1
     /// one.two = 12
     /// ```
-    Expr {
-        prefix: Option<String>,
-        name: String,
-        kind: Kind,
-    },
+    Expr(String, Op),
     /// ```lua
     /// ---@export <module>
     /// or
@@ -107,16 +99,29 @@ pub enum TagType {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Kind {
-    Dot,
-    Colon,
+pub enum Op {
+    Deep(Vec<Op>),
+    Dot(String),
+    Colon(String),
 }
 
-impl Kind {
-    pub fn as_char(&self) -> char {
+impl Display for Op {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Dot => '.',
-            Self::Colon => ':',
+            Self::Deep(mixed) => {
+                for mix in mixed {
+                    mix.fmt(f)?;
+                }
+                Ok(())
+            }
+            Self::Dot(dot) => {
+                f.write_str(".")?;
+                f.write_str(dot)
+            }
+            Self::Colon(colon) => {
+                f.write_str(":")?;
+                f.write_str(colon)
+            }
         }
     }
 }

src/parser/tags/func.rs

@@ -1,7 +1,7 @@
 use chumsky::{select, Parser};
 
 use crate::{
-    lexer::{Kind, Name, TagType, Ty},
+    lexer::{Name, Op, TagType, Ty},
     parser::{impl_parse, Prefix, See},
 };
 
@@ -62,8 +62,7 @@ impl_parse!(Return, {
 
 #[derive(Debug, Clone)]
 pub struct Func {
-    pub name: String,
-    pub kind: Kind,
+    pub op: Op,
     pub prefix: Prefix,
     pub desc: Vec<String>,
     pub params: Vec<Param>,
@@ -81,14 +80,13 @@ impl_parse!(Func, {
     .then(Return::parse().repeated())
     .then(See::parse())
     .then(Usage::parse().or_not())
-    .then(select! { TagType::Func { prefix, name, kind } => (prefix, name, kind) })
+    .then(select! { TagType::Func(prefix, op) => (prefix, op) })
     .map(
-        |(((((desc, params), returns), see), usage), (prefix, name, kind))| Self {
-            name,
-            kind,
+        |(((((desc, params), returns), see), usage), (prefix, op))| Self {
+            op,
             prefix: Prefix {
-                left: prefix.clone(),
-                right: prefix,
+                left: Some(prefix.clone()),
+                right: Some(prefix),
             },
             desc,
             params,

src/parser/tags/type.rs

@@ -1,18 +1,17 @@
 use chumsky::{select, Parser};
 
 use crate::{
-    lexer::{Kind, TagType, Ty},
+    lexer::{Op, TagType, Ty},
     parser::{impl_parse, Prefix, See},
 };
 
 use super::Usage;
 
 #[derive(Debug, Clone)]
 pub struct Type {
-    pub prefix: Prefix,
-    pub name: String,
     pub desc: (Vec<String>, Option<String>),
-    pub kind: Kind,
+    pub op: Op,
+    pub prefix: Prefix,
     pub ty: Ty,
     pub see: See,
     pub usage: Option<Usage>,
@@ -26,16 +25,15 @@ impl_parse!(Type, {
     .then(select! { TagType::Type(ty, desc) => (ty, desc) })
     .then(See::parse())
     .then(Usage::parse().or_not())
-    .then(select! { TagType::Expr { prefix, name, kind } => (prefix, name, kind) })
+    .then(select! { TagType::Expr(prefix, op) => (prefix, op) })
     .map(
-        |((((extract, (ty, desc)), see), usage), (prefix, name, kind))| Self {
+        |((((extract, (ty, desc)), see), usage), (prefix, op))| Self {
             desc: (extract, desc),
             prefix: Prefix {
-                left: prefix.clone(),
-                right: prefix,
+                left: Some(prefix.to_owned()),
+                right: Some(prefix),
             },
-            name,
-            kind,
+            op,
             ty,
             see,
             usage,

src/vimdoc/func.rs

@@ -19,28 +19,17 @@ impl ToDoc for FuncDoc {
                 .join(", ");
 
             format!(
-                "{}{}{}({args})",
+                "{}{}({args})",
                 n.prefix.left.as_deref().unwrap_or_default(),
-                n.kind.as_char(),
-                n.name
+                n.op
             )
         } else {
-            format!(
-                "{}{}{}()",
-                n.prefix.left.as_deref().unwrap_or_default(),
-                n.kind.as_char(),
-                n.name
-            )
+            format!("{}{}()", n.prefix.left.as_deref().unwrap_or_default(), n.op)
         };
 
         doc.push_str(&header!(
             name_with_param,
-            &format!(
-                "{}{}{}",
-                n.prefix.right.as_deref().unwrap_or_default(),
-                n.kind.as_char(),
-                n.name,
-            )
+            &format!("{}{}", n.prefix.right.as_deref().unwrap_or_default(), n.op)
         ));
 
         if !n.desc.is_empty() {

src/vimdoc/type.rs

@@ -11,18 +11,8 @@ impl ToDoc for TypeDoc {
         let mut doc = String::new();
 
         doc.push_str(&header!(
-            &format!(
-                "{}{}{}",
-                n.prefix.left.as_deref().unwrap_or_default(),
-                n.kind.as_char(),
-                n.name
-            ),
-            &format!(
-                "{}{}{}",
-                n.prefix.right.as_deref().unwrap_or_default(),
-                n.kind.as_char(),
-                n.name
-            )
+            &format!("{}{}", n.prefix.left.as_deref().unwrap_or_default(), n.op),
+            &format!("{}{}", n.prefix.right.as_deref().unwrap_or_default(), n.op)
         ));
 
         let (extract, desc) = &n.desc;

tests/basic.rs

@@ -179,7 +179,7 @@ CommentConfig                                                    *CommentConfig*
 #[test]
 fn functions() {
     let src = r#"
-    local U = {}
+    local U = { foo = {} }
 
     ---NOTE: Local functions are not part of the documentation
     ---Multiply two integer and print it
@@ -232,6 +232,19 @@ fn functions() {
     ---@param ... unknown
     function U.with_var_arg_end(x, ...) end
 
+    ---Class method deep access
+    ---@return table
+    function U.foo:bar()
+        self.__index = self
+        return setmetatable({}, self)
+    end
+
+    ---Method deep access
+    ---@return table
+    function U.foo.baz()
+        return U.foo:bar()
+    end
+
     return U
     "#;
 
@@ -299,6 +312,20 @@ U.with_var_arg_end({x}, {...})                              *U.with_var_arg_end*
         {...}  (unknown)
 
 
+U.foo:bar()                                                          *U.foo:bar*
+    Class method deep access
+
+    Returns: ~
+        (table)
+
+
+U.foo.baz()                                                          *U.foo.baz*
+    Method deep access
+
+    Returns: ~
+        (table)
+
+
 "
     )
 }