reference type

Author: numToStr

src/lexer.rs

@@ -12,6 +12,8 @@ use chumsky::{
 
 type Spanned = (TagType, Range<usize>);
 
+const C: [char; 3] = ['.', '_', '-'];
+
 #[derive(Debug)]
 pub struct Lexer;
 
@@ -267,6 +269,11 @@ impl Lexer {
                 .delimited_by(just('{').then(whitespace()), whitespace().then(just('}')))
                 .map(Ty::Dict);
 
+            let ty_name = filter(|x: &char| x.is_alphanumeric() || C.contains(x))
+                .repeated()
+                .collect()
+                .map(Ty::Ref);
+
             choice((
                 union_array(any, inner.clone()),
                 union_array(unknown, inner.clone()),
@@ -281,7 +288,8 @@ impl Lexer {
                 union_array(lightuserdata, inner.clone()),
                 union_array(fun, inner.clone()),
                 union_array(table, inner.clone()),
-                union_array(dict, inner),
+                union_array(dict, inner.clone()),
+                union_array(ty_name, inner),
             ))
         })
     }

src/lexer/token.rs

@@ -163,10 +163,56 @@ pub enum Ty {
     Table(Option<(Box<Ty>, Box<Ty>)>),
     Fun(Vec<(String, Ty)>, Option<Box<Ty>>),
     Dict(Vec<(String, Ty)>),
+    Ref(String),
 }
 
 impl Display for Ty {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("ty-ty")
+        match self {
+            Self::Nil => f.write_str("nil"),
+            Self::Any => f.write_str("any"),
+            Self::Unknown => f.write_str("unknown"),
+            Self::Boolean => f.write_str("boolean"),
+            Self::String => f.write_str("string"),
+            Self::Number => f.write_str("number"),
+            Self::Integer => f.write_str("integer"),
+            Self::Function => f.write_str("function"),
+            Self::Thread => f.write_str("thread"),
+            Self::Userdata => f.write_str("userdata"),
+            Self::Lightuserdata => f.write_str("lightuserdata"),
+            Self::Union(rhs, lhs) => write!(f, "{rhs}|{lhs}"),
+            Self::Array(ty) => write!(f, "{ty}[]"),
+            Self::Table(spec) => match spec {
+                Some((k, v)) => write!(f, "table<{k}, {v}>"),
+                None => f.write_str("table"),
+            },
+            Self::Fun(args, ret) => {
+                write!(
+                    f,
+                    "fun({})",
+                    args.iter()
+                        .map(|(arg, ty)| format!("{arg}: {ty}"))
+                        .collect::<Vec<String>>()
+                        .join(",")
+                )?;
+                if let Some(ret) = ret {
+                    write!(f, ": {}", ret)?;
+                }
+                Ok(())
+            }
+            Self::Dict(kv) => {
+                f.write_str("{ ")?;
+                write!(
+                    f,
+                    "{}",
+                    kv.iter()
+                        .map(|(arg, ty)| format!("{arg}: {ty}"))
+                        .collect::<Vec<String>>()
+                        .join(",")
+                )?;
+                f.write_str(" }")
+            }
+            Self::Ref(id) => f.write_str(id),
+        }
     }
 }

src/vimdoc/alias.rs

@@ -31,7 +31,8 @@ impl Display for AliasDoc<'_> {
         match &kind {
             AliasKind::Type(ty) => {
                 description!(f, "Type: ~")?;
-                writeln!(f, "{:>w$}", ty, w = 8 + ty.to_string().len())?;
+                let ty = ty.to_string();
+                writeln!(f, "{:>w$}", ty, w = 8 + ty.len())?;
             }
             AliasKind::Enum(variants) => {
                 description!(f, "Variants: ~")?;

tests/basic.rs

@@ -161,16 +161,16 @@ CommentConfig                                                    *CommentConfig*
     Plugin's configuration
 
     Fields: ~
-        {padding}    (boolean)                     Add a space b/w comment and the line
-        {sticky}     (boolean)                     Whether the cursor should stay at its position
-                                                   NOTE: This only affects NORMAL mode mappings and doesn't work with dot-repeat
+        {padding}    (boolean)                       Add a space b/w comment and the line
+        {sticky}     (boolean)                       Whether the cursor should stay at its position
+                                                     NOTE: This only affects NORMAL mode mappings and doesn't work with dot-repeat
 
-        {ignore}     (string|fun():string)         Lines to be ignored while comment/uncomment.
-                                                   Could be a regex string or a function that returns a regex string.
-                                                   Example: Use '^$' to ignore empty lines
+        {ignore}     (string|fun(): string)          Lines to be ignored while comment/uncomment.
+                                                     Could be a regex string or a function that returns a regex string.
+                                                     Example: Use '^$' to ignore empty lines
 
-        {pre_hook}   (fun(ctx:CommentCtx):string)  Function to be called before comment/uncomment
-        {post_hook}  (fun(ctx:CommentCtx))         Function to be called after comment/uncomment
+        {pre_hook}   (fun(ctx: CommentCtx): string)  Function to be called before comment/uncomment
+        {post_hook}  (fun(ctx: CommentCtx))          Function to be called after comment/uncomment
 
 
 "