Don't use capabilities for test mode detection

Author: MichaReiser

crates/ty/src/lib.rs

@@ -269,9 +269,10 @@ impl MainLoop {
                     // Spawn a new task that checks the project. This needs to be done in a separate thread
                     // to prevent blocking the main loop here.
                     rayon::spawn(move || {
-                        let reporter = IndicatifReporter::from(self.printer);
+                        let mut reporter = IndicatifReporter::from(self.printer);
+                        let bar = reporter.bar.clone();
+
                         match salsa::Cancelled::catch(|| {
-                            let mut reporter = reporter.clone();
                             db.check_with_reporter(&mut reporter);
                             reporter.collector.into_sorted(&db)
                         }) {
@@ -282,7 +283,7 @@ impl MainLoop {
                                     .unwrap();
                             }
                             Err(cancelled) => {
-                                reporter.bar.finish_and_clear();
+                                bar.finish_and_clear();
                                 tracing::debug!("Check has been cancelled: {cancelled:?}");
                             }
                         }
@@ -392,7 +393,6 @@ impl MainLoop {
 }
 
 /// A progress reporter for `ty check`.
-#[derive(Clone)]
 struct IndicatifReporter {
     collector: CollectReporter,
 

crates/ty_server/src/lib.rs

@@ -47,7 +47,7 @@ pub fn run_server() -> anyhow::Result<()> {
     // This is to complement the `LSPSystem` if the document is not available in the index.
     let fallback_system = Arc::new(OsSystem::new(cwd));
 
-    let server_result = Server::new(worker_threads, connection, fallback_system, true)
+    let server_result = Server::new(worker_threads, connection, fallback_system, false)
         .context("Failed to start server")?
         .run();
 

crates/ty_server/src/server.rs

@@ -33,7 +33,6 @@ pub use api::{PartialWorkspaceProgress, PartialWorkspaceProgressParams};
 
 pub struct Server {
     connection: Connection,
-    client_capabilities: ClientCapabilities,
     worker_threads: NonZeroUsize,
     main_loop_receiver: MainLoopReceiver,
     main_loop_sender: MainLoopSender,
@@ -45,7 +44,7 @@ impl Server {
         worker_threads: NonZeroUsize,
         connection: Connection,
         native_system: Arc<dyn System + 'static + Send + Sync + RefUnwindSafe>,
-        initialize_logging: bool,
+        in_test: bool,
     ) -> crate::Result<Self> {
         let (id, init_value) = connection.initialize_start()?;
         let init_params: InitializeParams = serde_json::from_value(init_value)?;
@@ -82,7 +81,7 @@ impl Server {
         let (main_loop_sender, main_loop_receiver) = crossbeam::channel::bounded(32);
         let client = Client::new(main_loop_sender.clone(), connection.sender.clone());
 
-        if initialize_logging {
+        if !in_test {
             crate::logging::init_logging(
                 global_options.tracing.log_level.unwrap_or_default(),
                 global_options.tracing.log_file.as_deref(),
@@ -161,8 +160,8 @@ impl Server {
                 global_options,
                 workspaces,
                 native_system,
+                in_test,
             )?,
-            client_capabilities,
         })
     }
 

crates/ty_server/src/server/api/requests/workspace_diagnostic.rs

@@ -203,7 +203,7 @@ impl<'a> ResponseWriter<'a> {
                 first: true,
                 client: client.clone(),
                 token,
-                is_test: snapshot.resolved_client_capabilities().is_test_server(),
+                is_test: snapshot.in_test(),
                 last_flush: Instant::now(),
                 batched: Vec::new(),
                 unchanged: Vec::with_capacity(previous_result_ids.len()),

crates/ty_server/src/server/main_loop.rs

@@ -227,11 +227,9 @@ impl Server {
             );
 
         let fs_watcher = self
-            .client_capabilities
-            .workspace
-            .as_ref()
-            .and_then(|workspace| workspace.did_change_watched_files?.dynamic_registration)
-            .unwrap_or_default();
+            .session
+            .client_capabilities()
+            .supports_did_change_watched_files_dynamic_registration();
 
         if fs_watcher {
             let registration = lsp_types::Registration {

crates/ty_server/src/session.rs

@@ -77,6 +77,9 @@ pub(crate) struct Session {
     /// Has the client requested the server to shutdown.
     shutdown_requested: bool,
 
+    /// Is the connected client a `TestServer` instance.
+    in_test: bool,
+
     deferred_messages: VecDeque<Message>,
 }
 
@@ -113,6 +116,7 @@ impl Session {
         global_options: GlobalOptions,
         workspace_folders: Vec<(Url, ClientOptions)>,
         native_system: Arc<dyn System + 'static + Send + Sync + RefUnwindSafe>,
+        in_test: bool,
     ) -> crate::Result<Self> {
         let index = Arc::new(Index::new(global_options.into_settings()));
 
@@ -132,6 +136,7 @@ impl Session {
             resolved_client_capabilities: ResolvedClientCapabilities::new(client_capabilities),
             request_queue: RequestQueue::new(),
             shutdown_requested: false,
+            in_test,
         })
     }
 
@@ -458,6 +463,7 @@ impl Session {
                 .collect(),
             index: self.index.clone().unwrap(),
             position_encoding: self.position_encoding,
+            in_test: self.in_test,
             resolved_client_capabilities: self.resolved_client_capabilities,
         }
     }
@@ -649,6 +655,7 @@ pub(crate) struct SessionSnapshot {
     index: Arc<Index>,
     position_encoding: PositionEncoding,
     resolved_client_capabilities: ResolvedClientCapabilities,
+    in_test: bool,
 
     /// IMPORTANT: It's important that the databases come last, or at least,
     /// after any `Arc` that we try to extract or mutate in-place using `Arc::into_inner`
@@ -678,6 +685,10 @@ impl SessionSnapshot {
     pub(crate) fn resolved_client_capabilities(&self) -> ResolvedClientCapabilities {
         self.resolved_client_capabilities
     }
+
+    pub(crate) const fn in_test(&self) -> bool {
+        self.in_test
+    }
 }
 
 #[derive(Debug, Default)]

crates/ty_server/src/session/capabilities.rs

@@ -18,7 +18,7 @@ bitflags::bitflags! {
         const SIGNATURE_ACTIVE_PARAMETER_SUPPORT = 1 << 9;
         const HIERARCHICAL_DOCUMENT_SYMBOL_SUPPORT = 1 << 10;
         const WORK_DONE_PROGRESS = 1 << 11;
-        const TEST_SERVER = 1 << 12;
+        const DID_CHANGE_WATCHED_FILES_DYNAMIC_REGISTRATION= 1 << 12;
     }
 }
 
@@ -83,8 +83,9 @@ impl ResolvedClientCapabilities {
         self.contains(Self::WORK_DONE_PROGRESS)
     }
 
-    pub(crate) const fn is_test_server(self) -> bool {
-        self.contains(Self::TEST_SERVER)
+    /// Returns `true` if the client supports dynamic registration for watched files changes.
+    pub(crate) const fn supports_did_change_watched_files_dynamic_registration(self) -> bool {
+        self.contains(Self::DID_CHANGE_WATCHED_FILES_DYNAMIC_REGISTRATION)
     }
 
     pub(super) fn new(client_capabilities: &ClientCapabilities) -> Self {
@@ -212,12 +213,12 @@ impl ResolvedClientCapabilities {
         }
 
         if client_capabilities
-            .experimental
+            .workspace
             .as_ref()
-            .and_then(|experimental| experimental.get("ty_test_server"))
-            .is_some()
+            .and_then(|workspace| workspace.did_change_watched_files?.dynamic_registration)
+            .unwrap_or_default()
         {
-            flags |= Self::TEST_SERVER;
+            flags |= Self::DID_CHANGE_WATCHED_FILES_DYNAMIC_REGISTRATION;
         }
 
         flags

crates/ty_server/tests/e2e/main.rs

@@ -174,7 +174,7 @@ impl TestServer {
             let worker_threads = NonZeroUsize::new(1).unwrap();
             let test_system = Arc::new(TestSystem::new(os_system));
 
-            match Server::new(worker_threads, server_connection, test_system, false) {
+            match Server::new(worker_threads, server_connection, test_system, true) {
                 Ok(server) => {
                     if let Err(err) = server.run() {
                         panic!("Server stopped with error: {err:?}");