updated the attribute AST to allow usage in @return

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs

@@ -234,15 +234,21 @@ pub fn analyze_return(analyzer: &mut DocAnalyzer, tag: LuaDocTagReturn) -> Optio
 
     if let Some(closure) = find_owner_closure_or_report(analyzer, &tag) {
         let signature_id = LuaSignatureId::from_closure(analyzer.file_id, &closure);
-        let returns = tag.get_type_and_name_list();
-        for (doc_type, name_token) in returns {
+        let returns = tag.get_info_list();
+        for (doc_type, name_token, attribute_use_tag) in returns {
             let name = name_token.map(|name| name.get_name_text().to_string());
 
             let type_ref = infer_type(analyzer, doc_type);
+            let attributes = if let Some(attribute) = attribute_use_tag {
+                infer_attribute_uses(analyzer, attribute)
+            } else {
+                None
+            };
             let return_info = LuaDocReturnInfo {
                 name,
                 type_ref,
                 description: description.clone(),
+                attributes,
             };
 
             let signature = analyzer

crates/emmylua_code_analysis/src/compilation/analyzer/lua/closure.rs

@@ -151,6 +151,7 @@ fn analyze_return(
                 type_ref: LuaType::Unknown,
                 description: None,
                 name: None,
+                attributes: None,
             }]
         }
         Err(reason) => {
@@ -236,6 +237,7 @@ pub fn analyze_return_point(
         type_ref: return_type,
         description: None,
         name: None,
+        attributes: None,
     }])
 }
 

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/check_reason.rs

@@ -97,6 +97,7 @@ pub fn resolve_as_any(db: &mut DbIndex, reason: &InferFailReason, loop_count: us
                     name: None,
                     type_ref: LuaType::Any,
                     description: None,
+                    attributes: None,
                 }];
                 signature.resolve_return = SignatureReturnStatus::InferResolve;
             }

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs

@@ -172,6 +172,7 @@ pub fn try_resolve_closure_return(
         name: None,
         type_ref: ret_type.clone(),
         description: None,
+        attributes: None,
     });
 
     signature.resolve_return = SignatureReturnStatus::DocResolve;
@@ -482,6 +483,7 @@ fn resolve_doc_function(
             name: None,
             type_ref: doc_func.get_ret().clone(),
             description: None,
+            attributes: None,
         });
     }
 

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -190,6 +190,7 @@ pub struct LuaDocReturnInfo {
     pub name: Option<String>,
     pub type_ref: LuaType,
     pub description: Option<String>,
+    pub attributes: Option<Vec<LuaAttributeUse>>,
 }
 
 #[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)]

crates/emmylua_ls/src/handlers/semantic_token/build_semantic_tokens.rs

@@ -371,8 +371,8 @@ fn build_node_semantic_token(
             );
         }
         LuaAst::LuaDocTagReturn(doc_return) => {
-            let type_name_list = doc_return.get_type_and_name_list();
-            for (_, name) in type_name_list {
+            let type_name_list = doc_return.get_info_list();
+            for (_, name, _) in type_name_list {
                 if let Some(name) = name {
                     builder.push(name.syntax(), SemanticTokenType::VARIABLE);
                 }

crates/emmylua_parser/src/grammar/doc/tag.rs

@@ -341,17 +341,24 @@ fn parse_tag_param(p: &mut LuaDocParser) -> DocParseResult {
 // ---@return number
 // ---@return number, string
 // ---@return number <name> , this just compact luals
+// ---@return [attribute] number
 fn parse_tag_return(p: &mut LuaDocParser) -> DocParseResult {
     p.set_state(LuaDocLexerState::Normal);
     let m = p.mark(LuaSyntaxKind::DocTagReturn);
     p.bump();
+    if p.current_token() == LuaTokenKind::TkLeftBracket {
+        parse_tag_attribute_use(p, false)?;
+    }
 
     parse_type(p)?;
 
     if_token_bump(p, LuaTokenKind::TkName);
 
     while p.current_token() == LuaTokenKind::TkComma {
         p.bump();
+        if p.current_token() == LuaTokenKind::TkLeftBracket {
+            parse_tag_attribute_use(p, false)?;
+        }
         parse_type(p)?;
         if_token_bump(p, LuaTokenKind::TkName);
     }

crates/emmylua_parser/src/grammar/doc/test.rs

@@ -2937,21 +2937,22 @@ Syntax(Chunk)@0..105
     }
 
     #[test]
-    fn test_attribute_generic_param() {
+    fn test_attribute_embedded() {
         let code = r#"
         ---@generic [attribute] T, [attribute] R
         ---@param [attribute] a number
+        ---@return [attribute] number, [attribute] string
         "#;
-        // print_ast(code);
+        print_ast(code);
         // print_ast(r#"
         // ---@class A<[attribute] T, [attribute] R>
         // "#);
         let result = r#"
-Syntax(Chunk)@0..97
-  Syntax(Block)@0..97
+Syntax(Chunk)@0..155
+  Syntax(Block)@0..155
     Token(TkEndOfLine)@0..1 "\n"
     Token(TkWhitespace)@1..9 "        "
-    Syntax(Comment)@9..88
+    Syntax(Comment)@9..146
       Token(TkDocStart)@9..13 "---@"
       Syntax(DocTagGeneric)@13..49
         Token(TkTagGeneric)@13..20 "generic"
@@ -2994,8 +2995,34 @@ Syntax(Chunk)@0..97
         Token(TkWhitespace)@81..82 " "
         Syntax(TypeName)@82..88
           Token(TkName)@82..88 "number"
-    Token(TkEndOfLine)@88..89 "\n"
-    Token(TkWhitespace)@89..97 "        "
+      Token(TkEndOfLine)@88..89 "\n"
+      Token(TkWhitespace)@89..97 "        "
+      Token(TkDocStart)@97..101 "---@"
+      Syntax(DocTagReturn)@101..146
+        Token(TkTagReturn)@101..107 "return"
+        Token(TkWhitespace)@107..108 " "
+        Syntax(DocTagAttributeUse)@108..119
+          Token(TkLeftBracket)@108..109 "["
+          Syntax(DocAttributeUse)@109..118
+            Syntax(TypeName)@109..118
+              Token(TkName)@109..118 "attribute"
+          Token(TkRightBracket)@118..119 "]"
+        Token(TkWhitespace)@119..120 " "
+        Syntax(TypeName)@120..126
+          Token(TkName)@120..126 "number"
+        Token(TkComma)@126..127 ","
+        Token(TkWhitespace)@127..128 " "
+        Syntax(DocTagAttributeUse)@128..139
+          Token(TkLeftBracket)@128..129 "["
+          Syntax(DocAttributeUse)@129..138
+            Syntax(TypeName)@129..138
+              Token(TkName)@129..138 "attribute"
+          Token(TkRightBracket)@138..139 "]"
+        Token(TkWhitespace)@139..140 " "
+        Syntax(TypeName)@140..146
+          Token(TkName)@140..146 "string"
+    Token(TkEndOfLine)@146..147 "\n"
+    Token(TkWhitespace)@147..155 "        "
         "#;
         assert_ast_eq!(code, result);
     }

crates/emmylua_parser/src/syntax/node/doc/tag.rs

@@ -534,32 +534,43 @@ impl LuaDocTagReturn {
         self.children()
     }
 
-    pub fn get_type_and_name_list(&self) -> Vec<(LuaDocType, Option<LuaNameToken>)> {
+    pub fn get_info_list(
+        &self,
+    ) -> Vec<(
+        LuaDocType,
+        Option<LuaNameToken>,
+        Option<LuaDocTagAttributeUse>,
+    )> {
         let mut result = Vec::new();
         let mut current_type = None;
         let mut current_name = None;
+        let mut current_attribute = None;
         for child in self.syntax.children_with_tokens() {
             match child.kind() {
                 LuaKind::Token(LuaTokenKind::TkComma) => {
                     if let Some(type_) = current_type {
-                        result.push((type_, current_name));
+                        result.push((type_, current_name, current_attribute));
                     }
                     current_type = None;
                     current_name = None;
+                    current_attribute = None;
                 }
                 LuaKind::Token(LuaTokenKind::TkName) => {
                     current_name = Some(LuaNameToken::cast(child.into_token().unwrap()).unwrap());
                 }
                 k if LuaDocType::can_cast(k.into()) => {
                     current_type = Some(LuaDocType::cast(child.into_node().unwrap()).unwrap());
                 }
-
+                a if LuaDocTagAttributeUse::can_cast(a.into()) => {
+                    current_attribute =
+                        Some(LuaDocTagAttributeUse::cast(child.into_node().unwrap()).unwrap());
+                }
                 _ => {}
             }
         }
 
         if let Some(type_) = current_type {
-            result.push((type_, current_name));
+            result.push((type_, current_name, current_attribute));
         }
 
         result