completion: optimize class_attr_completion

Author: xuhuanzy

crates/emmylua_ls/src/handlers/completion/providers/doc_name_token_provider.rs

@@ -2,8 +2,8 @@ use std::collections::HashSet;
 
 use emmylua_code_analysis::{DiagnosticCode, LuaTypeAttribute};
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaClosureExpr, LuaComment, LuaDocAttribute, LuaSyntaxKind, LuaSyntaxToken,
-    LuaTokenKind,
+    LuaAst, LuaAstNode, LuaClosureExpr, LuaComment, LuaDocAttribute, LuaDocTag, LuaSyntaxKind,
+    LuaSyntaxToken, LuaTokenKind,
 };
 use lsp_types::CompletionItem;
 
@@ -29,8 +29,8 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
         DocCompletionExpected::DiagnosticCode => {
             add_tag_diagnostic_code_completion(builder);
         }
-        DocCompletionExpected::ClassAttr => {
-            add_tag_class_attr_completion(builder);
+        DocCompletionExpected::ClassAttr(node) => {
+            add_tag_class_attr_completion(builder, node);
         }
         DocCompletionExpected::Namespace => {
             add_tag_namespace_completion(builder);
@@ -84,7 +84,10 @@ fn get_doc_completion_expected(trigger_token: &LuaSyntaxToken) -> Option<DocComp
                         LuaSyntaxKind::DocDiagnosticCodeList => {
                             Some(DocCompletionExpected::DiagnosticCode)
                         }
-                        LuaSyntaxKind::DocAttribute => Some(DocCompletionExpected::ClassAttr),
+                        LuaSyntaxKind::DocAttribute => {
+                            let attr = LuaDocAttribute::cast(parent.clone().into())?;
+                            Some(DocCompletionExpected::ClassAttr(attr))
+                        }
                         _ => None,
                     }
                 }
@@ -102,28 +105,34 @@ fn get_doc_completion_expected(trigger_token: &LuaSyntaxToken) -> Option<DocComp
             let parent = trigger_token.parent()?;
             match parent.kind().into() {
                 LuaSyntaxKind::DocDiagnosticCodeList => Some(DocCompletionExpected::DiagnosticCode),
-                LuaSyntaxKind::DocAttribute => Some(DocCompletionExpected::ClassAttr),
+                LuaSyntaxKind::DocAttribute => {
+                    let attr = LuaDocAttribute::cast(parent.clone().into())?;
+                    Some(DocCompletionExpected::ClassAttr(attr))
+                }
                 _ => None,
             }
         }
         LuaTokenKind::TkLeftParen => {
             let parent = trigger_token.parent()?;
             match parent.kind().into() {
-                LuaSyntaxKind::DocAttribute => Some(DocCompletionExpected::ClassAttr),
+                LuaSyntaxKind::DocAttribute => {
+                    let attr = LuaDocAttribute::cast(parent.clone().into())?;
+                    Some(DocCompletionExpected::ClassAttr(attr))
+                }
                 _ => None,
             }
         }
         _ => return None,
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 enum DocCompletionExpected {
     ParamName,
     Cast,
     DiagnosticAction,
     DiagnosticCode,
-    ClassAttr,
+    ClassAttr(LuaDocAttribute),
     Namespace,
     Using,
     Export,
@@ -219,42 +228,30 @@ fn add_tag_diagnostic_code_completion(builder: &mut CompletionBuilder) {
     }
 }
 
-fn add_tag_class_attr_completion(builder: &mut CompletionBuilder) {
-    let attributes = [
-        (LuaTypeAttribute::Partial, "partial"),
-        (LuaTypeAttribute::Key, "key"),
-        (LuaTypeAttribute::Constructor, "constructor"),
-        (LuaTypeAttribute::Exact, "exact"),
-        (LuaTypeAttribute::Meta, "meta"),
-    ];
+fn add_tag_class_attr_completion(
+    builder: &mut CompletionBuilder,
+    node: LuaDocAttribute,
+) -> Option<()> {
+    let mut attributes = vec![(LuaTypeAttribute::Partial, "partial")];
 
-    // 已存在的属性
-    let mut existing_attrs = HashSet::new();
-    match builder.trigger_token.kind().into() {
-        LuaTokenKind::TkLeftParen | LuaTokenKind::TkComma => {
-            let parent = builder.trigger_token.parent().unwrap();
-            let attr = LuaDocAttribute::cast(parent).unwrap();
-            for token in attr.get_attrib_tokens() {
-                let name_text = token.get_name_text().to_string();
-                existing_attrs.insert(name_text);
-            }
+    match LuaDocTag::cast(node.syntax().parent()?)? {
+        LuaDocTag::Alias(_) => {}
+        LuaDocTag::Class(_) => {
+            attributes.push((LuaTypeAttribute::Exact, "exact"));
+            attributes.push((LuaTypeAttribute::Constructor, "constructor"));
         }
-        LuaTokenKind::TkWhitespace => {
-            let left_token = builder.trigger_token.prev_token().unwrap();
-            match left_token.kind().into() {
-                LuaTokenKind::TkComma => {
-                    let parent = left_token.parent().unwrap();
-                    let attr = LuaDocAttribute::cast(parent).unwrap();
-                    for token in attr.get_attrib_tokens() {
-                        let name_text = token.get_name_text().to_string();
-                        existing_attrs.insert(name_text);
-                    }
-                }
-                _ => {}
-            }
+        LuaDocTag::Enum(_) => {
+            attributes.insert(0, (LuaTypeAttribute::Key, "key"));
+            attributes.push((LuaTypeAttribute::Exact, "exact"));
         }
         _ => {}
     }
+    // 已存在的属性
+    let mut existing_attrs = HashSet::new();
+    for token in node.get_attrib_tokens() {
+        let name_text = token.get_name_text().to_string();
+        existing_attrs.insert(name_text);
+    }
 
     for (_, name) in attributes.iter() {
         if existing_attrs.contains(*name) {
@@ -267,6 +264,8 @@ fn add_tag_class_attr_completion(builder: &mut CompletionBuilder) {
         };
         builder.add_completion_item(completion_item);
     }
+
+    Some(())
 }
 
 fn add_tag_namespace_completion(builder: &mut CompletionBuilder) {

crates/emmylua_ls/src/handlers/test/completion_test.rs

@@ -469,23 +469,13 @@ mod tests {
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
-                VirtualCompletionItem {
-                    label: "key".to_string(),
-                    kind: CompletionItemKind::ENUM_MEMBER,
-                    ..Default::default()
-                },
-                VirtualCompletionItem {
-                    label: "constructor".to_string(),
-                    kind: CompletionItemKind::ENUM_MEMBER,
-                    ..Default::default()
-                },
                 VirtualCompletionItem {
                     label: "exact".to_string(),
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
                 VirtualCompletionItem {
-                    label: "meta".to_string(),
+                    label: "constructor".to_string(),
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
@@ -499,23 +489,13 @@ mod tests {
             ---@field a string
             "#,
             vec![
-                VirtualCompletionItem {
-                    label: "key".to_string(),
-                    kind: CompletionItemKind::ENUM_MEMBER,
-                    ..Default::default()
-                },
-                VirtualCompletionItem {
-                    label: "constructor".to_string(),
-                    kind: CompletionItemKind::ENUM_MEMBER,
-                    ..Default::default()
-                },
                 VirtualCompletionItem {
                     label: "exact".to_string(),
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
                 VirtualCompletionItem {
-                    label: "meta".to_string(),
+                    label: "constructor".to_string(),
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
@@ -525,8 +505,8 @@ mod tests {
 
         assert!(ws.check_completion_with_kind(
             r#"
-            ---@class (partial, <??>) C
-            ---@field a string
+            ---@enum (<??>) C
+
             "#,
             vec![
                 VirtualCompletionItem {
@@ -535,7 +515,7 @@ mod tests {
                     ..Default::default()
                 },
                 VirtualCompletionItem {
-                    label: "constructor".to_string(),
+                    label: "partial".to_string(),
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
@@ -544,11 +524,6 @@ mod tests {
                     kind: CompletionItemKind::ENUM_MEMBER,
                     ..Default::default()
                 },
-                VirtualCompletionItem {
-                    label: "meta".to_string(),
-                    kind: CompletionItemKind::ENUM_MEMBER,
-                    ..Default::default()
-                },
             ],
             CompletionTriggerKind::TRIGGER_CHARACTER,
         ));