feat: lsp complete for exteranl pkg import

kclvm/parser/src/lib.rs

@@ -337,7 +337,6 @@ impl Loader {
 
             // Insert an empty vec to determine whether there is a circular import.
             pkgs.insert(kclvm_ast::MAIN_PKG.to_string(), vec![]);
-
             self.load_import_package(
                 &entry.path(),
                 entry.name().to_string(),
@@ -527,7 +526,7 @@ impl Loader {
 
         if pkg_info.k_files.is_empty() {
             self.missing_pkgs.push(pkgpath);
-            return Ok(None);
+            return Ok(Some(pkg_info));
         }
 
         let mut pkg_files = Vec::new();

kclvm/tools/src/LSP/src/completion.rs

@@ -36,6 +36,7 @@ use kclvm_sema::ty::{FunctionType, SchemaType, Type};
 use lsp_types::{CompletionItem, CompletionItemKind};
 
 use crate::goto_def::{find_def, get_identifier_last_name, Definition};
+use crate::util::get_real_path_from_external;
 use crate::util::{inner_most_expr_in_stmt, is_in_docstring, is_in_schema_expr};
 
 #[derive(Debug, Clone, PartialEq, Hash, Eq)]
@@ -411,8 +412,12 @@ fn completion_for_import(
 ) -> Option<lsp_types::CompletionResponse> {
     let mut items: IndexSet<KCLCompletionItem> = IndexSet::new();
     let pkgpath = &stmt.path;
-    let real_path =
+    let mut real_path =
         Path::new(&program.root).join(pkgpath.replace('.', &std::path::MAIN_SEPARATOR.to_string()));
+    if !real_path.exists() {
+        real_path =
+            get_real_path_from_external(&stmt.pkg_name, pkgpath, program.root.clone().into());
+    }
     if real_path.is_dir() {
         if let Ok(entries) = fs::read_dir(real_path) {
             let mut entries = entries
@@ -1003,7 +1008,7 @@ mod tests {
     #[bench_test]
     fn import_builtin_package() {
         let (file, program, prog_scope, _, gs) =
-            compile_test_file("src/test_data/completion_test/import/import.k");
+            compile_test_file("src/test_data/completion_test/import/builtin_pkg.k");
         let mut items: IndexSet<KCLCompletionItem> = IndexSet::new();
 
         // test completion for builtin packages
@@ -1232,4 +1237,33 @@ mod tests {
             CompletionResponse::List(_) => panic!("test failed"),
         }
     }
+
+    use crate::util::parse_param_and_compile;
+    use crate::util::Param;
+    use parking_lot::RwLock;
+    use std::sync::Arc;
+
+    #[test]
+    fn schema_docstring_newl111ine_completion() {
+        let (file, program, prog_scope, _, _) = {
+            let file = "/Users/zz/code/KCLVM/kclvm/tools/src/LSP/src/test_data/goto_import_def_test/main.k".to_string();
+
+            let (program, prog_scope, diags, gs) = parse_param_and_compile(
+                Param { file: file.clone() },
+                Some(Arc::new(RwLock::new(Default::default()))),
+            )
+            .unwrap();
+            (file, program, prog_scope, diags, gs)
+        };
+
+        // test completion for builtin packages
+        let pos = KCLPos {
+            filename: file.to_owned(),
+            line: 1,
+            column: Some(14),
+        };
+
+        let got = completion(Some('.'), &program, &pos, &prog_scope).unwrap();
+        println!("{:?}", got);
+    }
 }

kclvm/tools/src/LSP/src/test_data/completion_test/import/external/kcl.mod

@@ -0,0 +1,2 @@
+[package]
+

kclvm/tools/src/LSP/src/test_data/completion_test/import/external/main.k

@@ -0,0 +1 @@
+import k8s

kclvm/tools/src/LSP/src/tests.rs

@@ -371,6 +371,66 @@ fn file_path_from_url_test() {
     }
 }
 
+#[test]
+fn complete_import_external_file_test() {
+    let path = PathBuf::from(".")
+        .join("src")
+        .join("test_data")
+        .join("completion_test")
+        .join("import")
+        .join("external")
+        .join("main.k")
+        .canonicalize()
+        .unwrap()
+        .display()
+        .to_string();
+
+    let _ = Command::new("kpm")
+        .arg("metadata")
+        .arg("--update")
+        .current_dir(
+            PathBuf::from(".")
+                .join("src")
+                .join("test_data")
+                .join("goto_import_def_test")
+                .canonicalize()
+                .unwrap()
+                .display()
+                .to_string(),
+        )
+        .output()
+        .unwrap();
+
+    let (program, prog_scope, _, _) = parse_param_and_compile(
+        Param {
+            file: path.to_string(),
+        },
+        Some(Arc::new(RwLock::new(Default::default()))),
+    )
+    .unwrap();
+
+    // test goto import file: import .pkg.schema_def
+    let pos = KCLPos {
+        filename: path.to_string(),
+        line: 1,
+        column: Some(11),
+    };
+    let res = completion(Some('.'), &program, &pos, &prog_scope).unwrap();
+
+    let got_labels: Vec<String> = match &res {
+        CompletionResponse::Array(arr) => arr.iter().map(|item| item.label.clone()).collect(),
+        CompletionResponse::List(_) => panic!("test failed"),
+    };
+    let expected_labels: Vec<&str> = vec![
+        "api",
+        "apiextensions_apiserver",
+        "apimachinery",
+        "kube_aggregator",
+        "vendor",
+    ];
+    assert_eq!(got_labels, expected_labels);
+}
+
 #[test]
 fn goto_import_external_file_test() {
     let path = PathBuf::from(".")