feat(lsp): add inferred type request (#35099)

Adds a `deno/inferredType` custom LSP request that returns the full
TypeScript QuickInfo display string and source range for the symbol at a
text document position. The TypeScript quick-info bridge now passes an
explicit large `maximumLength`, so hover and inferred-type callers avoid
the default truncation.

Also advertises a `refactor.extract.inferredType` code action titled
"Copy inferred type". The code action carries the precomputed inferred
type text as command data, giving clients a discoverable native entry
point for copying full inferred type text while allowing editor
extensions to own clipboard access.

Companion VS Code extension PR: denoland/vscode_deno#1381

Verification:
- `cargo build --bin deno`
- `cargo fmt --check`
- `cargo test -p integration_tests --test integration lsp_inferred_type
-- --nocapture`
- `cargo build -p test_server`
- `cargo test -p integration_tests --test integration lsp_hover --
--nocapture`

Refs #23901
Closes denoland/divybot#425

---------

Co-authored-by: divybot <divybot@users.noreply.github.com>
Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

cli/lsp/capabilities.rs

@@ -5,12 +5,21 @@
 //! language server, which helps determine what messages are sent from the
 //! client.
 //!
+use std::sync::LazyLock;
+
 use deno_core::serde_json::json;
 use tower_lsp::lsp_types::*;
 
 use super::refactor::ALL_KNOWN_REFACTOR_ACTION_KINDS;
 use super::semantic_tokens::get_legend;
 
+pub static INFERRED_TYPE_CODE_ACTION_KIND: LazyLock<CodeActionKind> =
+  LazyLock::new(|| {
+    [CodeActionKind::REFACTOR_EXTRACT.as_str(), "inferredType"]
+      .join(".")
+      .into()
+  });
+
 fn code_action_capabilities(
   client_capabilities: &ClientCapabilities,
 ) -> CodeActionProviderCapability {
@@ -23,6 +32,7 @@ fn code_action_capabilities(
       let mut code_action_kinds = vec![
         CodeActionKind::QUICKFIX,
         CodeActionKind::REFACTOR,
+        INFERRED_TYPE_CODE_ACTION_KIND.clone(),
         CodeActionKind::SOURCE_ORGANIZE_IMPORTS,
       ];
       code_action_kinds.extend(

cli/lsp/language_server.rs

@@ -62,6 +62,7 @@ use super::analysis::fix_ts_import_changes;
 use super::analysis::ts_changes_to_edit;
 use super::cache::LspCache;
 use super::capabilities;
+use super::capabilities::INFERRED_TYPE_CODE_ACTION_KIND;
 use super::capabilities::semantic_tokens_registration_options;
 use super::client::Client;
 use super::code_lens;
@@ -81,6 +82,7 @@ use super::jsr::CliJsrSearchApi;
 use super::logging::lsp_log;
 use super::logging::lsp_warn;
 use super::lsp_custom;
+use super::lsp_custom::INFERRED_TYPE_COMMAND;
 use super::lsp_custom::TaskDefinition;
 use super::npm::CliNpmSearchApi;
 use super::parent_process_checker;
@@ -500,6 +502,32 @@ impl LanguageServer {
     Ok(Some(self.inner.read().await.get_performance()))
   }
 
+  pub async fn inferred_type(
+    &self,
+    params: Option<Value>,
+    token: CancellationToken,
+  ) -> LspResult<Option<Value>> {
+    self.init_flag.wait_raised().await;
+    match params.map(serde_json::from_value) {
+      Some(Ok(params)) => Ok(Some(
+        serde_json::to_value(
+          self
+            .inner
+            .read()
+            .await
+            .inferred_type(params, &token)
+            .await?,
+        )
+        .map_err(|err| {
+          error!("Failed to serialize inferred_type response: {:#}", err);
+          LspError::internal_error()
+        })?,
+      )),
+      Some(Err(err)) => Err(LspError::invalid_params(err.to_string())),
+      None => Err(LspError::invalid_params("Missing parameters")),
+    }
+  }
+
   pub async fn task_definitions(
     &self,
     _token: CancellationToken,
@@ -2187,6 +2215,63 @@ impl Inner {
     let mut deno_lint_actions = Vec::new();
     let mut deno_test_actions = Vec::new();
     let mut includes_no_cache = false;
+    if params.context.only.as_ref().is_none_or(|only| {
+      only.iter().any(|kind| {
+        INFERRED_TYPE_CODE_ACTION_KIND
+          .as_str()
+          .starts_with(kind.as_str())
+      })
+    }) {
+      let snapshot = self.snapshot();
+      let response = self
+        .ts_server
+        .provide_inferred_type(&module, params.range.start, snapshot, token)
+        .await
+        .map_err(|err| {
+          if token.is_cancelled() {
+            LspError::request_cancelled()
+          } else {
+            error!(
+              "Unable to get inferred type code action from TypeScript: {:#}",
+              err
+            );
+            LspError::internal_error()
+          }
+        })?;
+      if let Some(response) = response {
+        deno_actions.push(CodeAction {
+          title: "Copy inferred type".to_string(),
+          kind: Some(INFERRED_TYPE_CODE_ACTION_KIND.clone()),
+          command: Some(Command {
+            title: "Copy inferred type".to_string(),
+            command: INFERRED_TYPE_COMMAND.to_string(),
+            arguments: Some(vec![
+              serde_json::to_value(lsp_custom::InferredTypeParams {
+                text_document: TextDocumentIdentifier {
+                  uri: params.text_document.uri.clone(),
+                },
+                position: params.range.start,
+              })
+              .map_err(|err| {
+                error!(
+                  "Failed to serialize inferred type command params: {:#}",
+                  err
+                );
+                LspError::internal_error()
+              })?,
+              serde_json::to_value(response).map_err(|err| {
+                error!(
+                  "Failed to serialize inferred type command response: {:#}",
+                  err
+                );
+                LspError::internal_error()
+              })?,
+            ]),
+          }),
+          ..Default::default()
+        });
+      }
+    }
     if self.config.specifier_enabled_for_test(&module.specifier)
       && let Some(Ok(parsed_source)) = &module
         .open_data
@@ -4684,6 +4769,43 @@ impl Inner {
     self.performance.measure(mark);
     Ok(contents)
   }
+
+  async fn inferred_type(
+    &self,
+    params: lsp_custom::InferredTypeParams,
+    token: &CancellationToken,
+  ) -> LspResult<Option<lsp_custom::InferredTypeResponse>> {
+    let mark = self
+      .performance
+      .mark_with_args("lsp.inferred_type", &params);
+    let Some(document) = self.get_document(
+      &params.text_document.uri,
+      Enabled::Filter,
+      Exists::Enforce,
+      Diagnosable::Filter,
+    )?
+    else {
+      return Ok(None);
+    };
+    let Some(module) = self.get_primary_module(&document)? else {
+      return Ok(None);
+    };
+    let snapshot = self.snapshot();
+    let response = self
+      .ts_server
+      .provide_inferred_type(&module, params.position, snapshot, token)
+      .await
+      .map_err(|err| {
+        if token.is_cancelled() {
+          LspError::request_cancelled()
+        } else {
+          error!("Unable to get inferred type from TypeScript: {:#}", err);
+          LspError::internal_error()
+        }
+      })?;
+    self.performance.measure(mark);
+    Ok(response)
+  }
 }
 
 #[cfg(test)]

cli/lsp/lsp_custom.rs

@@ -5,9 +5,25 @@ use deno_core::serde::Serialize;
 use tower_lsp::lsp_types as lsp;
 
 pub const PERFORMANCE_REQUEST: &str = "deno/performance";
+pub const INFERRED_TYPE_REQUEST: &str = "deno/inferredType";
+pub const INFERRED_TYPE_COMMAND: &str = "deno.inferredType";
 pub const TASK_REQUEST: &str = "deno/taskDefinitions";
 pub const VIRTUAL_TEXT_DOCUMENT: &str = "deno/virtualTextDocument";
 
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InferredTypeParams {
+  pub text_document: lsp::TextDocumentIdentifier,
+  pub position: lsp::Position,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InferredTypeResponse {
+  pub text: String,
+  pub range: lsp::Range,
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TaskDefinition {

cli/lsp/mod.rs

@@ -49,6 +49,10 @@ pub async fn start() -> Result<(), AnyError> {
     lsp_custom::PERFORMANCE_REQUEST,
     LanguageServer::performance_request,
   )
+  .custom_method(
+    lsp_custom::INFERRED_TYPE_REQUEST,
+    LanguageServer::inferred_type,
+  )
   .custom_method(lsp_custom::TASK_REQUEST, LanguageServer::task_definitions)
   .custom_method(testing::TEST_RUN_REQUEST, LanguageServer::test_run_request)
   .custom_method(

cli/lsp/refactor.rs

@@ -130,6 +130,20 @@ pub static REWRITE_PROPERTY_GENERATEACCESSORS: Lazy<RefactorCodeActionKind> =
     }),
   });
 
+pub static INFER_FUNCTION_RETURN_TYPE: Lazy<RefactorCodeActionKind> =
+  Lazy::new(|| RefactorCodeActionKind {
+    kind: [
+      lsp::CodeActionKind::REFACTOR_REWRITE.as_str(),
+      "function",
+      "returnType",
+    ]
+    .join(".")
+    .into(),
+    matches_callback: Box::new(|tag: &str| {
+      tag.starts_with("Infer function return type")
+    }),
+  });
+
 pub static ALL_KNOWN_REFACTOR_ACTION_KINDS: Lazy<
   Vec<&'static RefactorCodeActionKind>,
 > = Lazy::new(|| {
@@ -144,6 +158,7 @@ pub static ALL_KNOWN_REFACTOR_ACTION_KINDS: Lazy<
     &REWRITE_ARROW_BRACES,
     &REWRITE_PARAMETERS_TO_DESTRUCTURED,
     &REWRITE_PROPERTY_GENERATEACCESSORS,
+    &INFER_FUNCTION_RETURN_TYPE,
   ]
 });
 

cli/lsp/ts_server.rs

@@ -26,6 +26,7 @@ use crate::lsp::diagnostics::ts_json_to_diagnostics;
 use crate::lsp::documents::Document;
 use crate::lsp::language_server;
 use crate::lsp::logging::lsp_warn;
+use crate::lsp::lsp_custom;
 use crate::lsp::performance::Performance;
 use crate::lsp::refactor;
 use crate::lsp::tsc::TsJsServer;
@@ -295,6 +296,31 @@ impl TsServer {
     }
   }
 
+  pub async fn provide_inferred_type(
+    &self,
+    module: &DocumentModule,
+    position: lsp::Position,
+    snapshot: Arc<StateSnapshot>,
+    token: &CancellationToken,
+  ) -> Result<Option<lsp_custom::InferredTypeResponse>, AnyError> {
+    match self {
+      Self::Js(ts_server) => {
+        let position = module.line_index.offset_tsc(position)?;
+        let quick_info = ts_server
+          .get_quick_info(snapshot.clone(), module, position, token)
+          .await?;
+        Ok(quick_info.and_then(|quick_info| {
+          quick_info.display_string(module, &snapshot).map(|text| {
+            lsp_custom::InferredTypeResponse {
+              text,
+              range: quick_info.to_range(module),
+            }
+          })
+        }))
+      }
+    }
+  }
+
   #[allow(clippy::too_many_arguments, reason = "TODO: cleanup")]
   pub async fn provide_code_actions(
     &self,

cli/lsp/tsc.rs

@@ -106,6 +106,8 @@ use crate::util::path::relative_specifier;
 use crate::util::path::to_percent_decoded_str;
 use crate::util::v8::convert;
 
+const QUICK_INFO_MAX_LENGTH: u32 = 1_000_000;
+
 static BRACKET_ACCESSOR_RE: Lazy<Regex> =
   lazy_regex!(r#"^\[['"](.+)[\['"]\]$"#);
 static CODEBLOCK_RE: Lazy<Regex> = lazy_regex!(r"^\s*[~`]{3}"m);
@@ -723,6 +725,7 @@ impl TsJsServer {
         .specifier_map
         .denormalize(&module.specifier, module.media_type),
       position,
+      QUICK_INFO_MAX_LENGTH,
     ));
     self
       .request(
@@ -2091,18 +2094,29 @@ fn display_parts_to_string<'a>(
 }
 
 impl QuickInfo {
+  pub fn display_string(
+    &self,
+    module: &DocumentModule,
+    snapshot: &StateSnapshot,
+  ) -> Option<String> {
+    self
+      .display_parts
+      .as_ref()
+      .map(|p| display_parts_to_string(p, module, snapshot))
+      .filter(|s| !s.is_empty())
+  }
+
+  pub fn to_range(&self, module: &DocumentModule) -> lsp::Range {
+    self.text_span.to_range(&module.line_index)
+  }
+
   pub fn to_hover(
     &self,
     module: &DocumentModule,
     snapshot: &StateSnapshot,
   ) -> lsp::Hover {
     let mut value = String::new();
-    if let Some(display_string) = self
-      .display_parts
-      .clone()
-      .map(|p| display_parts_to_string(&p, module, snapshot))
-      && !display_string.is_empty()
-    {
+    if let Some(display_string) = self.display_string(module, snapshot) {
       value.push_str("```tsx\n");
       value.push_str(&display_string);
       value.push_str("\n```\n");
@@ -6418,7 +6432,7 @@ enum TscRequest {
   GetNavigationTree((String,)),
   GetSupportedCodeFixes,
   // https://github.com/denoland/deno/blob/v1.37.1/cli/tsc/dts/typescript.d.ts#L6214
-  GetQuickInfoAtPosition((String, u32)),
+  GetQuickInfoAtPosition((String, u32, u32)),
   // https://github.com/denoland/deno/blob/v1.37.1/cli/tsc/dts/typescript.d.ts#L6257
   GetCodeFixesAtPosition(
     Box<(
@@ -6552,9 +6566,15 @@ impl TscRequest {
         ("getNavigationTree", Some(args.to_v8(scope)?))
       }
       TscRequest::GetSupportedCodeFixes => ("$getSupportedCodeFixes", None),
-      TscRequest::GetQuickInfoAtPosition((specifier, position)) => (
+      TscRequest::GetQuickInfoAtPosition((
+        specifier,
+        position,
+        maximum_length,
+      )) => (
         "getQuickInfoAtPosition",
-        Some((specifier, Number(position)).to_v8(scope)?),
+        Some(
+          (specifier, Number(position), Number(maximum_length)).to_v8(scope)?,
+        ),
       ),
       TscRequest::GetCodeFixesAtPosition(args) => (
         "getCodeFixesAtPosition",