[ty] Add LSP debug information command (#20379)

Co-authored-by: Micha Reiser <[email protected]>

Author: Guillaume-Fgt

crates/ty_python_semantic/src/lint.rs

@@ -463,7 +463,7 @@ impl From<&'static LintMetadata> for LintEntry {
     }
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq, get_size2::GetSize)]
+#[derive(Clone, Default, PartialEq, Eq, get_size2::GetSize)]
 pub struct RuleSelection {
     /// Map with the severity for each enabled lint rule.
     ///
@@ -541,6 +541,35 @@ impl RuleSelection {
     }
 }
 
+// The default `LintId` debug implementation prints the entire lint metadata.
+// This is way too verbose.
+impl fmt::Debug for RuleSelection {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let lints = self.lints.iter().sorted_by_key(|(lint, _)| lint.name);
+
+        if f.alternate() {
+            let mut f = f.debug_map();
+
+            for (lint, (severity, source)) in lints {
+                f.entry(
+                    &lint.name().as_str(),
+                    &format_args!("{severity:?} ({source:?})"),
+                );
+            }
+
+            f.finish()
+        } else {
+            let mut f = f.debug_set();
+
+            for (lint, _) in lints {
+                f.entry(&lint.name());
+            }
+
+            f.finish()
+        }
+    }
+}
+
 #[derive(Default, Copy, Clone, Debug, PartialEq, Eq, get_size2::GetSize)]
 pub enum LintSource {
     /// The user didn't enable the rule explicitly, instead it's enabled by default.

crates/ty_server/src/capabilities.rs

@@ -10,6 +10,8 @@ use lsp_types::{
 
 use crate::PositionEncoding;
 use crate::session::GlobalSettings;
+use lsp_types as types;
+use std::str::FromStr;
 
 bitflags::bitflags! {
     /// Represents the resolved client capabilities for the language server.
@@ -37,6 +39,36 @@ bitflags::bitflags! {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum SupportedCommand {
+    Debug,
+}
+
+impl SupportedCommand {
+    /// Returns the identifier of the command.
+    const fn identifier(self) -> &'static str {
+        match self {
+            SupportedCommand::Debug => "ty.printDebugInformation",
+        }
+    }
+
+    /// Returns all the commands that the server currently supports.
+    const fn all() -> [SupportedCommand; 1] {
+        [SupportedCommand::Debug]
+    }
+}
+
+impl FromStr for SupportedCommand {
+    type Err = anyhow::Error;
+
+    fn from_str(name: &str) -> anyhow::Result<Self, Self::Err> {
+        Ok(match name {
+            "ty.printDebugInformation" => Self::Debug,
+            _ => return Err(anyhow::anyhow!("Invalid command `{name}`")),
+        })
+    }
+}
+
 impl ResolvedClientCapabilities {
     /// Returns `true` if the client supports workspace diagnostic refresh.
     pub(crate) const fn supports_workspace_diagnostic_refresh(self) -> bool {
@@ -319,6 +351,15 @@ pub(crate) fn server_capabilities(
 
     ServerCapabilities {
         position_encoding: Some(position_encoding.into()),
+        execute_command_provider: Some(types::ExecuteCommandOptions {
+            commands: SupportedCommand::all()
+                .map(|command| command.identifier().to_string())
+                .to_vec(),
+            work_done_progress_options: WorkDoneProgressOptions {
+                work_done_progress: Some(false),
+            },
+        }),
+
         diagnostic_provider,
         text_document_sync: Some(TextDocumentSyncCapability::Options(
             TextDocumentSyncOptions {

crates/ty_server/src/server/api.rs

@@ -32,6 +32,7 @@ pub(super) fn request(req: server::Request) -> Task {
     let id = req.id.clone();
 
     match req.method.as_str() {
+        requests::ExecuteCommand::METHOD => sync_request_task::<requests::ExecuteCommand>(req),
         requests::DocumentDiagnosticRequestHandler::METHOD => background_document_request_task::<
             requests::DocumentDiagnosticRequestHandler,
         >(

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

@@ -2,6 +2,7 @@ mod completion;
 mod diagnostic;
 mod doc_highlights;
 mod document_symbols;
+mod execute_command;
 mod goto_declaration;
 mod goto_definition;
 mod goto_references;
@@ -22,6 +23,7 @@ pub(super) use completion::CompletionRequestHandler;
 pub(super) use diagnostic::DocumentDiagnosticRequestHandler;
 pub(super) use doc_highlights::DocumentHighlightRequestHandler;
 pub(super) use document_symbols::DocumentSymbolRequestHandler;
+pub(super) use execute_command::ExecuteCommand;
 pub(super) use goto_declaration::GotoDeclarationRequestHandler;
 pub(super) use goto_definition::GotoDefinitionRequestHandler;
 pub(super) use goto_references::ReferencesRequestHandler;

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

@@ -0,0 +1,76 @@
+use crate::capabilities::SupportedCommand;
+use crate::server;
+use crate::server::api::LSPResult;
+use crate::server::api::RequestHandler;
+use crate::server::api::traits::SyncRequestHandler;
+use crate::session::Session;
+use crate::session::client::Client;
+use lsp_server::ErrorCode;
+use lsp_types::{self as types, request as req};
+use std::fmt::Write;
+use std::str::FromStr;
+use ty_project::Db;
+
+pub(crate) struct ExecuteCommand;
+
+impl RequestHandler for ExecuteCommand {
+    type RequestType = req::ExecuteCommand;
+}
+
+impl SyncRequestHandler for ExecuteCommand {
+    fn run(
+        session: &mut Session,
+        _client: &Client,
+        params: types::ExecuteCommandParams,
+    ) -> server::Result<Option<serde_json::Value>> {
+        let command = SupportedCommand::from_str(&params.command)
+            .with_failure_code(ErrorCode::InvalidParams)?;
+
+        match command {
+            SupportedCommand::Debug => Ok(Some(serde_json::Value::String(
+                debug_information(session).with_failure_code(ErrorCode::InternalError)?,
+            ))),
+        }
+    }
+}
+
+/// Returns a string with detailed memory usage.
+fn debug_information(session: &Session) -> crate::Result<String> {
+    let mut buffer = String::new();
+
+    writeln!(
+        buffer,
+        "Client capabilities: {:#?}",
+        session.client_capabilities()
+    )?;
+    writeln!(
+        buffer,
+        "Position encoding: {:#?}",
+        session.position_encoding()
+    )?;
+    writeln!(buffer, "Global settings: {:#?}", session.global_settings())?;
+    writeln!(
+        buffer,
+        "Open text documents: {}",
+        session.text_document_keys().count()
+    )?;
+    writeln!(buffer)?;
+
+    for (root, workspace) in session.workspaces() {
+        writeln!(buffer, "Workspace {root} ({})", workspace.url())?;
+        writeln!(buffer, "Settings: {:#?}", workspace.settings())?;
+        writeln!(buffer)?;
+    }
+
+    for db in session.project_dbs() {
+        writeln!(buffer, "Project at {}", db.project().root(db))?;
+        writeln!(buffer, "Settings: {:#?}", db.project().settings(db))?;
+        writeln!(buffer)?;
+        writeln!(
+            buffer,
+            "Memory report:\n{}",
+            db.salsa_memory_dump().display_full()
+        )?;
+    }
+    Ok(buffer)
+}

crates/ty_server/tests/e2e/commands.rs

@@ -0,0 +1,55 @@
+use anyhow::Result;
+use lsp_types::{ExecuteCommandParams, WorkDoneProgressParams, request::ExecuteCommand};
+use ruff_db::system::SystemPath;
+
+use crate::{TestServer, TestServerBuilder};
+
+// Sends an executeCommand request to the TestServer
+fn execute_command(
+    server: &mut TestServer,
+    command: String,
+    arguments: Vec<serde_json::Value>,
+) -> anyhow::Result<Option<serde_json::Value>> {
+    let params = ExecuteCommandParams {
+        command,
+        arguments,
+        work_done_progress_params: WorkDoneProgressParams::default(),
+    };
+    let id = server.send_request::<ExecuteCommand>(params);
+    server.await_response::<ExecuteCommand>(&id)
+}
+
+#[test]
+fn debug_command() -> Result<()> {
+    let workspace_root = SystemPath::new("src");
+    let foo = SystemPath::new("src/foo.py");
+    let foo_content = "\
+def foo() -> str:
+return 42
+";
+
+    let mut server = TestServerBuilder::new()?
+        .with_workspace(workspace_root, None)?
+        .with_file(foo, foo_content)?
+        .enable_pull_diagnostics(false)
+        .build()?
+        .wait_until_workspaces_are_initialized()?;
+
+    let response = execute_command(&mut server, "ty.printDebugInformation".to_string(), vec![])?;
+    let response = response.expect("expect server response");
+
+    let response = response
+        .as_str()
+        .expect("debug command to return a string response");
+
+    insta::with_settings!({
+        filters =>vec![
+            (r"\b[0-9]+.[0-9]+MB\b","[X.XXMB]"),
+            (r"Workspace .+\)","Workspace XXX"),
+            (r"Project at .+","Project at XXX"),
+    ]}, {
+        insta::assert_snapshot!(response);
+    });
+
+    Ok(())
+}

crates/ty_server/tests/e2e/main.rs

@@ -27,6 +27,7 @@
 //! [`await_request`]: TestServer::await_request
 //! [`await_notification`]: TestServer::await_notification
 
+mod commands;
 mod initialize;
 mod inlay_hints;
 mod publish_diagnostics;