completion: add @namespace @using

Author: xuhuanzy

crates/emmylua_code_analysis/src/db_index/type/mod.rs

@@ -207,6 +207,15 @@ impl LuaTypeIndex {
         self.full_name_type_map.values().collect()
     }
 
+    pub fn get_file_namespaces(&self) -> Vec<String> {
+        self.file_namespace
+            .values()
+            .cloned()
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .collect()
+    }
+
     pub fn get_type_decl_mut(&mut self, decl_id: &LuaTypeDeclId) -> Option<&mut LuaTypeDecl> {
         self.full_name_type_map.get_mut(decl_id)
     }

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

@@ -32,6 +32,12 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
         DocCompletionExpected::ClassAttr => {
             add_tag_class_attr_completion(builder);
         }
+        DocCompletionExpected::Namespace => {
+            add_tag_namespace_completion(builder);
+        }
+        DocCompletionExpected::Using => {
+            add_tag_using_completion(builder);
+        }
     }
 
     builder.stop_here();
@@ -66,6 +72,8 @@ fn get_doc_completion_expected(trigger_token: &LuaSyntaxToken) -> Option<DocComp
                         _ => None,
                     }
                 }
+                LuaTokenKind::TkTagNamespace => Some(DocCompletionExpected::Namespace),
+                LuaTokenKind::TkTagUsing => Some(DocCompletionExpected::Using),
                 LuaTokenKind::TkComma => {
                     let parent = left_token.parent()?;
                     match parent.kind().into() {
@@ -112,6 +120,8 @@ enum DocCompletionExpected {
     DiagnosticAction,
     DiagnosticCode,
     ClassAttr,
+    Namespace,
+    Using,
 }
 
 fn add_tag_param_name_completion(builder: &mut CompletionBuilder) -> Option<()> {
@@ -253,3 +263,46 @@ fn add_tag_class_attr_completion(builder: &mut CompletionBuilder) {
         builder.add_completion_item(completion_item);
     }
 }
+
+fn add_tag_namespace_completion(builder: &mut CompletionBuilder) {
+    let type_index = builder.semantic_model.get_db().get_type_index();
+    let file_id = builder.semantic_model.get_file_id();
+    if type_index.get_file_namespace(&file_id).is_some() {
+        return;
+    }
+    let mut namespaces = type_index.get_file_namespaces();
+
+    namespaces.sort();
+
+    for (sorted_index, namespace) in namespaces.iter().enumerate() {
+        let completion_item = CompletionItem {
+            label: namespace.clone(),
+            kind: Some(lsp_types::CompletionItemKind::MODULE),
+            sort_text: Some(format!("{:03}", sorted_index)),
+            ..Default::default()
+        };
+        builder.add_completion_item(completion_item);
+    }
+}
+
+fn add_tag_using_completion(builder: &mut CompletionBuilder) {
+    let type_index = builder.semantic_model.get_db().get_type_index();
+    let file_id = builder.semantic_model.get_file_id();
+    let current_namespace = type_index.get_file_namespace(&file_id);
+    let mut namespaces = type_index.get_file_namespaces();
+    if let Some(current_namespace) = current_namespace {
+        namespaces.retain(|namespace| namespace != current_namespace);
+    }
+    namespaces.sort();
+
+    for (sorted_index, namespace) in namespaces.iter().enumerate() {
+        let completion_item = CompletionItem {
+            label: format!("using {}", namespace),
+            kind: Some(lsp_types::CompletionItemKind::MODULE),
+            sort_text: Some(format!("{:03}", sorted_index)),
+            insert_text: Some(format!("{}", namespace)),
+            ..Default::default()
+        };
+        builder.add_completion_item(completion_item);
+    }
+}

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

@@ -1,7 +1,9 @@
 use std::collections::HashSet;
 
 use emmylua_code_analysis::{LuaFlowId, LuaSignatureId, LuaType, LuaVarRefId};
-use emmylua_parser::{LuaAst, LuaAstNode, LuaCallArgList, LuaClosureExpr, LuaParamList};
+use emmylua_parser::{
+    LuaAst, LuaAstNode, LuaCallArgList, LuaClosureExpr, LuaParamList, LuaTokenKind,
+};
 use lsp_types::{CompletionItem, CompletionItemKind, CompletionTriggerKind};
 
 use crate::handlers::completion::{
@@ -56,6 +58,10 @@ fn check_can_add_completion(builder: &CompletionBuilder) -> Option<()> {
         }
     } else if builder.trigger_kind == CompletionTriggerKind::INVOKED {
         let parent = builder.trigger_token.parent()?;
+        let prev_token = builder.trigger_token.prev_token()?;
+        if prev_token.kind() == LuaTokenKind::TkTagUsing.into() {
+            return None;
+        }
         // 即时是主动触发, 也不允许在函数定义的参数列表中添加
         if trigger_text == "(" {
             if LuaParamList::can_cast(parent.kind().into()) {

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

@@ -977,4 +977,62 @@ mod tests {
             CompletionTriggerKind::TRIGGER_CHARACTER,
         ));
     }
+
+    #[test]
+    fn test_namespace_base() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@namespace Reactive
+            "#,
+        );
+        ws.def(
+            r#"
+                ---@namespace AlienSignals
+            "#,
+        );
+        assert!(ws.check_completion_with_kind(
+            r#"
+            ---@namespace <??>
+
+            "#,
+            vec![
+                VirtualCompletionItem {
+                    label: "AlienSignals".to_string(),
+                    kind: CompletionItemKind::MODULE,
+                    ..Default::default()
+                },
+                VirtualCompletionItem {
+                    label: "Reactive".to_string(),
+                    kind: CompletionItemKind::MODULE,
+                    ..Default::default()
+                },
+            ],
+            CompletionTriggerKind::TRIGGER_CHARACTER,
+        ));
+
+        assert!(ws.check_completion_with_kind(
+            r#"
+            ---@namespace Reactive
+            ---@namespace <??>
+
+            "#,
+            vec![],
+            CompletionTriggerKind::TRIGGER_CHARACTER,
+        ));
+
+        assert!(ws.check_completion_with_kind(
+            r#"
+            ---@namespace Reactive
+            ---@using <??>
+
+            "#,
+            vec![VirtualCompletionItem {
+                label: "using AlienSignals".to_string(),
+                kind: CompletionItemKind::MODULE,
+                ..Default::default()
+            },],
+            CompletionTriggerKind::INVOKED,
+        ));
+    }
 }