fix(lsp): malfunctioning on unsaved files, empty workspaceFolder parameter, overlay use with prefixes (nushell#16568)

Fixes some minor issues of nu-lsp, including nushell#16559 and nushell#16539, as well
as most of the key takeaways of nushell#16540

## Release notes summary - What our users need to know

## Tasks after submitting

- [ ] add test cases, I'll leave them to future PRs where I'm going to
refactor the verbose testing code of nu-lsp.

Author: blindFS

crates/nu-lsp/src/ast.rs

@@ -134,21 +134,33 @@ fn try_find_id_in_def(
             }
         }
     }
-    let (name, span) = strip_quotes(span?, working_set);
-    let decl_id = Id::Declaration(working_set.find_decl(&name).or_else(|| {
-        // for defs inside def
+
+    let block_span_of_this_def = call.positional_iter().last()?.span;
+    let decl_on_spot = |decl_id: &DeclId| -> bool {
+        working_set
+            .get_decl(*decl_id)
+            .block_id()
+            .and_then(|block_id| working_set.get_block(block_id).span)
+            .is_some_and(|block_span| block_span == block_span_of_this_def)
+    };
+
+    let (_, span) = strip_quotes(span?, working_set);
+    let id_found = if let Some(id_r) = id_ref {
+        let Id::Declaration(decl_id_ref) = id_r else {
+            return None;
+        };
+        decl_on_spot(decl_id_ref).then_some(id_r.clone())?
+    } else {
+        // Find declaration by name, e.g. `workspace.find_decl`, is not reliable
+        // considering shadowing and overlay prefixes
         // TODO: get scope by position
         // https://github.com/nushell/nushell/issues/15291
-        (0..working_set.num_decls()).rev().find_map(|id| {
+        Id::Declaration((0..working_set.num_decls()).rev().find_map(|id| {
             let decl_id = DeclId::new(id);
-            let decl = working_set.get_decl(decl_id);
-            let span = working_set.get_block(decl.block_id()?).span?;
-            call.span().contains_span(span).then_some(decl_id)
-        })
-    })?);
-    id_ref
-        .is_none_or(|id_r| decl_id == *id_r)
-        .then_some((decl_id, span))
+            decl_on_spot(&decl_id).then_some(decl_id)
+        })?)
+    };
+    Some((id_found, span))
 }
 
 /// For situations like

crates/nu-lsp/src/completion.rs

@@ -14,9 +14,9 @@ use nu_protocol::{
 
 impl LanguageServer {
     pub(crate) fn complete(&mut self, params: &CompletionParams) -> Option<CompletionResponse> {
-        let path_uri = params.text_document_position.text_document.uri.to_owned();
+        let path_uri = &params.text_document_position.text_document.uri;
         let docs = self.docs.lock().ok()?;
-        let file = docs.get_document(&path_uri)?;
+        let file = docs.get_document(path_uri)?;
         let location = file.offset_at(params.text_document_position.position) as usize;
         let file_text = file.get_content(None).to_owned();
         drop(docs);
@@ -30,18 +30,18 @@ impl LanguageServer {
                 .is_some_and(|c| c.is_whitespace() || "|(){}[]<>,:;".contains(c));
 
         self.need_parse |= need_fallback;
-        let engine_state = Arc::new(self.new_engine_state(Some(&path_uri)));
+        let engine_state = Arc::new(self.new_engine_state(Some(path_uri)));
         let completer = NuCompleter::new(engine_state.clone(), Arc::new(Stack::new()));
         let results = if need_fallback {
             completer.fetch_completions_at(&file_text[..location], location)
         } else {
-            let file_path = uri_to_path(&path_uri);
+            let file_path = uri_to_path(path_uri);
             let filename = file_path.to_str()?;
             completer.fetch_completions_within_file(filename, location, &file_text)
         };
 
         let docs = self.docs.lock().ok()?;
-        let file = docs.get_document(&path_uri)?;
+        let file = docs.get_document(path_uri)?;
         (!results.is_empty()).then_some(CompletionResponse::Array(
             results
                 .into_iter()

crates/nu-lsp/src/goto.rs

@@ -15,16 +15,16 @@ impl LanguageServer {
         for cached_file in files.into_iter() {
             if cached_file.covered_span.contains(span.start) {
                 let path = Path::new(&*cached_file.name);
-                if !path.is_file() {
-                    return None;
-                }
                 let target_uri = path_to_uri(path);
                 if let Some(file) = self.docs.lock().ok()?.get_document(&target_uri) {
                     return Some(Location {
                         uri: target_uri,
                         range: span_to_range(span, file, cached_file.covered_span.start),
                     });
                 } else {
+                    if !path.is_file() {
+                        return None;
+                    }
                     // in case where the document is not opened yet,
                     // typically included by the `use/source` command
                     let temp_doc = FullTextDocument::new(
@@ -77,16 +77,12 @@ impl LanguageServer {
         &mut self,
         params: &GotoDefinitionParams,
     ) -> Option<GotoDefinitionResponse> {
-        let path_uri = params
-            .text_document_position_params
-            .text_document
-            .uri
-            .to_owned();
-        let mut engine_state = self.new_engine_state(Some(&path_uri));
+        let path_uri = &params.text_document_position_params.text_document.uri;
+        let mut engine_state = self.new_engine_state(Some(path_uri));
         let (working_set, id, _, _) = self
             .parse_and_find(
                 &mut engine_state,
-                &path_uri,
+                path_uri,
                 params.text_document_position_params.position,
             )
             .ok()?;

crates/nu-lsp/src/hover.rs

@@ -117,16 +117,12 @@ impl LanguageServer {
     }
 
     pub(crate) fn hover(&mut self, params: &HoverParams) -> Option<Hover> {
-        let path_uri = params
-            .text_document_position_params
-            .text_document
-            .uri
-            .to_owned();
-        let mut engine_state = self.new_engine_state(Some(&path_uri));
+        let path_uri = &params.text_document_position_params.text_document.uri;
+        let mut engine_state = self.new_engine_state(Some(path_uri));
         let (working_set, id, _, _) = self
             .parse_and_find(
                 &mut engine_state,
-                &path_uri,
+                path_uri,
                 params.text_document_position_params.position,
             )
             .ok()?;

crates/nu-lsp/src/lib.rs

@@ -234,6 +234,14 @@ impl LanguageServer {
                             })
                         }
                         request::Rename::METHOD => {
+                            if self.channels.is_some() {
+                                self.send_error_message(
+                                    request.id.clone(),
+                                    3,
+                                    "Please wait for renaming preparation to complete.".into(),
+                                )?;
+                                continue;
+                            }
                             Self::handle_lsp_request(request, |params| self.rename(params))
                         }
                         request::SemanticTokensFullRequest::METHOD => {
@@ -393,6 +401,7 @@ impl LanguageServer {
         let file_path = uri_to_path(uri);
         let file_path_str = file_path.to_str()?;
         let contents = file.get_content(None).as_bytes();
+        // For `const foo = path self .`
         let _ = working_set.files.push(file_path.clone(), Span::unknown());
         let block = nu_parser::parse(&mut working_set, Some(file_path_str), contents, false);
         let span = working_set.get_span_for_filename(file_path_str)?;

crates/nu-lsp/src/signature.rs

@@ -118,26 +118,22 @@ impl LanguageServer {
         &mut self,
         params: &SignatureHelpParams,
     ) -> Option<SignatureHelp> {
-        let path_uri = params
-            .text_document_position_params
-            .text_document
-            .uri
-            .to_owned();
+        let path_uri = &params.text_document_position_params.text_document.uri;
         let docs = self.docs.lock().ok()?;
-        let file = docs.get_document(&path_uri)?;
+        let file = docs.get_document(path_uri)?;
         let location = file.offset_at(params.text_document_position_params.position) as usize;
         let file_text = file.get_content(None).to_owned();
         drop(docs);
 
-        let engine_state = self.new_engine_state(Some(&path_uri));
+        let engine_state = self.new_engine_state(Some(path_uri));
         let mut working_set = StateWorkingSet::new(&engine_state);
 
         // NOTE: in case the cursor is at the end of the call expression
         let need_placeholder = location == 0
             || file_text
                 .get(location - 1..location)
                 .is_some_and(|s| s.chars().all(|c| c.is_whitespace()));
-        let file_path = uri_to_path(&path_uri);
+        let file_path = uri_to_path(path_uri);
         let filename = if need_placeholder {
             "lsp_signature_helper_temp_file"
         } else {

crates/nu-lsp/src/symbols.rs

@@ -274,12 +274,12 @@ impl LanguageServer {
         &mut self,
         params: &DocumentSymbolParams,
     ) -> Option<DocumentSymbolResponse> {
-        let uri = params.text_document.uri.to_owned();
-        let engine_state = self.new_engine_state(Some(&uri));
+        let uri = &params.text_document.uri;
+        let engine_state = self.new_engine_state(Some(uri));
         let docs = self.docs.lock().ok()?;
-        self.symbol_cache.update(&uri, &engine_state, &docs);
+        self.symbol_cache.update(uri, &engine_state, &docs);
         self.symbol_cache
-            .get_symbols_by_uri(&uri)
+            .get_symbols_by_uri(uri)
             .map(DocumentSymbolResponse::Flat)
     }