Only send inlay hint refresh requests on initial load

Editor itself is able to invalidate hints after edits, and /refresh was
sent after editor reports changes to the language server.
This forces the editor to either query & invalidate the hints twice
after every edit, or wait for /refresh to come before querying the
hints.

Both options are rather useless, so instead, send a request on server
startup only: client editors do not know when the server actually starts
up, this will help to query the initial hints after editor was open and
the server was still starting up.

Author: SomeoneToIgnore

crates/rust-analyzer/src/main_loop.rs

@@ -223,11 +223,12 @@ impl GlobalState {
 
                 for progress in prime_caches_progress {
                     let (state, message, fraction);
-                    match progress {
+                    let should_refresh = match progress {
                         PrimeCachesProgress::Begin => {
                             state = Progress::Begin;
                             message = None;
                             fraction = 0.0;
+                            false
                         }
                         PrimeCachesProgress::Report(report) => {
                             state = Progress::Report;
@@ -248,6 +249,7 @@ impl GlobalState {
                             };
 
                             fraction = Progress::fraction(report.crates_done, report.crates_total);
+                            false
                         }
                         PrimeCachesProgress::End { cancelled } => {
                             state = Progress::End;
@@ -259,10 +261,21 @@ impl GlobalState {
                                 self.prime_caches_queue
                                     .request_op("restart after cancellation".to_string(), ());
                             }
+                            !cancelled
                         }
                     };
 
                     self.report_progress("Indexing", state, message, Some(fraction), None);
+                    if should_refresh && self.config.inlay_hints_refresh() {
+                        // Refresh inlay hints if the client supports it.
+                        // Hint /refresh invalidates all hints globally, so do not send the queries after regular changes:
+                        // client editors are capable of invalidating the hints locally after the change.
+                        // But do send the /refresh request when the server [re]started — the client has no good way of knowing that.
+                        self.send_request::<lsp_types::request::InlayHintRefreshRequest>(
+                            (),
+                            |_, _| (),
+                        );
+                    }
                 }
             }
             Event::Vfs(message) => {
@@ -315,11 +328,6 @@ impl GlobalState {
                 if self.config.code_lens_refresh() {
                     self.send_request::<lsp_types::request::CodeLensRefresh>((), |_, _| ());
                 }
-
-                // Refresh inlay hints if the client supports it.
-                if self.config.inlay_hints_refresh() {
-                    self.send_request::<lsp_types::request::InlayHintRefreshRequest>((), |_, _| ());
-                }
             }
 
             let update_diagnostics = (!was_quiescent || state_changed || memdocs_added_or_removed)