laburnum 1.17.0

// Copyright Two Neutron Stars Incorporated and contributors
// SPDX-License-Identifier: BlueOak-1.0.0

use {
  crate::{
    TRACER,
    Uri,
    database::{
      DynPartition,
      PartitionWriteContextRef,
    },
    partitions::{
      Workspace,
      workspace::WorkspaceSortKey,
    },
    protocol::{
      jsonrpc,
      lsp::{
        DocumentChanges,
        NumberOrString,
        OneOf,
        WorkspaceFolder,
      },
      macros::lsp_enum,
      prelude::*,
    },
    scheduler::task::TaskContext,
  },
  serde::{
    Deserialize,
    Serialize,
  },
  std::collections::HashMap,
};

// WorkspaceEdit

/// A workspace edit represents changes to many resources managed in the
/// workspace.
///
/// The edit should either provide `changes` or `documentChanges`.
/// If the client can handle versioned document edits and if `documentChanges`
/// are present, the latter are preferred over `changes`.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceEdit {
  /// Holds changes to existing resources.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(default)]
  pub changes: Option<HashMap<Uri, Vec<TextEdit>>>, /*    changes?: { [uri:
                                                     * string]: TextEdit[];
                                                     * }; */

  /// Depending on the client capability
  /// `workspace.workspaceEdit.resourceOperations` document changes
  /// are either an array of `TextDocumentEdit`s to express changes to n
  /// different text documents where each text document edit addresses a
  /// specific version of a text document. Or it can contain
  /// above `TextDocumentEdit`s mixed with create, rename and delete file /
  /// folder operations.
  ///
  /// Whether a client supports versioned document edits is expressed via
  /// `workspace.workspaceEdit.documentChanges` client capability.
  ///
  /// If a client neither supports `documentChanges` nor
  /// `workspace.workspaceEdit.resourceOperations` then only plain
  /// `TextEdit`s using the `changes` property are supported.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_changes: Option<DocumentChanges>,

  /// A map of change annotations that can be referenced in
  /// `AnnotatedTextEdit`s or create, rename and delete file / folder
  /// operations.
  ///
  /// Whether clients honor this property depends on the client capability
  /// `workspace.changeAnnotationSupport`.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub change_annotations:
    Option<HashMap<ChangeAnnotationIdentifier, ChangeAnnotation>>,
}
impl WorkspaceEdit {
  #[must_use]
  pub fn new(changes: HashMap<Uri, Vec<TextEdit>>) -> Self {
    Self {
      changes: Some(changes),
      document_changes: None,
      ..Default::default()
    }
  }
}

pub trait WorkspaceService<
  P: crate::database::storage::Partitions,
  T: crate::protocol::lsp::LanguageServer<P>,
>: Send + Sync + 'static
{
  /// The [`workspace/didChangeConfiguration`] notification is sent from the
  /// client to the server to signal the change of configuration settings.
  ///
  /// [`workspace/didChangeConfiguration`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeConfiguration
  fn did_change_configuration(
    &self,
    params: DidChangeConfigurationParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      let config_json = match serde_json::to_string(&params.settings) {
        | Ok(json) => json,
        | Err(e) => {
          return;
        },
      };

      let _ = config_json;
    }
  }
  const DID_CHANGE_CONFIGURATION_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/didChangeWorkspaceFolders`] notification is sent from the
  /// client to the server to inform about workspace folder configuration
  /// changes.
  ///
  /// [`workspace/didChangeWorkspaceFolders`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWorkspaceFolders
  ///
  /// The notification is sent by default if both of these boolean fields were
  /// set to `true` in the [`initialize`](Self::initialize) method:
  ///
  /// * `InitializeParams::capabilities::workspace::workspace_folders`
  /// * `InitializeResult::capabilities::workspace::workspace_folders::supported`
  ///
  /// This notification is also sent if the server has registered itself to
  /// receive this notification.
  fn did_change_workspace_folders(
    &self,
    params: DidChangeWorkspaceFoldersParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      let source_cache = ctx.source_cache();
      let mut cache = source_cache.write();

      for folder in params.event.removed {
        cache.remove_workspace_folder(&folder.uri);
      }

      let glob_patterns = ctx.server().source_files_glob();
      let mut added_uris = Vec::new();

      for folder in params.event.added {
        cache.add_workspace_folder(folder.clone());
        added_uris.push(folder.uri);
      }

      drop(cache);

      if !added_uris.is_empty() && !glob_patterns.is_empty() {
        let task = crate::source::task::SourceCacheIndexTask::create(
          ctx.scheduler(),
          added_uris,
          glob_patterns,
        );
        ctx.scheduler().queue_task(task);
      }
    }
  }
  const DID_CHANGE_WORKSPACE_FOLDERS_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/didCreateFiles`] request is sent from the client to the
  /// server when files were created from within the client.
  ///
  /// [`workspace/didCreateFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didCreateFiles
  fn did_create_files(
    &self,
    params: CreateFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      otel::span!(
        "laburnum.lsp.did_create_files",
        "files.count" = params.files.len() as i64
      );
      let _ = ctx;
      let _ = writer;

      for file in params.files {
        match Uri::parse(&file.uri) {
          | Ok(uri) => {},
          | Err(e) => {},
        }
      }
    }
  }
  const DID_CREATE_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/didRenameFiles`] notification is sent from the client to
  /// the server when files were renamed from within the client.
  ///
  /// [`workspace/didRenameFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didRenameFiles
  fn did_rename_files(
    &self,
    params: RenameFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      otel::span!(
        "laburnum.lsp.did_rename_files",
        "files.count" = params.files.len() as i64
      );
      let _ = writer;
      let source_cache = ctx.source_cache();
      let mut cache = source_cache.write();

      for file in params.files {
        let old_uri = match Uri::parse(&file.old_uri) {
          | Ok(uri) => uri,
          | Err(e) => {
            continue;
          },
        };

        let new_uri = match Uri::parse(&file.new_uri) {
          | Ok(uri) => uri,
          | Err(e) => {
            continue;
          },
        };

        let new_uri_str = new_uri.to_string();
        if let Err(e) = cache.rename_file(&old_uri, new_uri) {
          otel::error!(
            "file_rename_failed",
            format!(
              "Failed to rename file from {} to {}: {:?}",
              old_uri, new_uri_str, e
            )
          );
        }
      }
    }
  }
  const DID_RENAME_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/didDeleteFiles`] notification is sent from the client to
  /// the server when files were deleted from within the client.
  ///
  /// [`workspace/didDeleteFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didDeleteFiles
  fn did_delete_files(
    &self,
    params: DeleteFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      otel::span!(
        "laburnum.lsp.did_delete_files",
        "files.count" = params.files.len() as i64
      );
      let _ = writer;
      let source_cache = ctx.source_cache();
      let mut cache = source_cache.write();

      for file in params.files {
        let uri = match Uri::parse(&file.uri) {
          | Ok(uri) => uri,
          | Err(e) => {
            continue;
          },
        };

        if let Err(e) = cache.delete_file(&uri) {
          otel::error!(
            "file_delete_failed",
            format!("Failed to delete file {}: {:?}", uri, e)
          );
        }
      }
    }
  }
  const DID_DELETE_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/didChangeWatchedFiles`] notification is sent from the
  /// client to the server when the client detects changes to files watched by
  /// the language client.
  ///
  /// [`workspace/didChangeWatchedFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWatchedFiles
  ///
  /// It is recommended that servers register for these file events using the
  /// registration mechanism. This can be done here or in the
  /// [`initialized`](Self::initialized) method using
  /// [`ConnectedClient`](crate::connect::lsp::ConnectedClient).
  fn did_change_watched_files(
    &self,
    params: DidChangeWatchedFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = ()> + Send {
    async move {
      let _ = writer;
      let source_cache = ctx.source_cache();

      for change in params.changes {
        match change.typ {
          | FileChangeType::CREATED => {},
          | FileChangeType::CHANGED => {},
          | FileChangeType::DELETED => {
            let mut cache = source_cache.write();
            if let Err(e) = cache.delete_file(&change.uri) {}
          },
          | _ => {},
        }
      }
    }
  }
  const DID_CHANGE_WATCHED_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  const WORKSPACE_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;
}

pub trait WorkspaceHooksService<
  P: crate::database::storage::Partitions,
  T: crate::protocol::lsp::LanguageServer<P>,
>: Send + Sync + 'static
{
  /// The [`workspace/willCreateFiles`] request is sent from the client to the
  /// server before files are actually created as long as the creation is
  /// triggered from within the client.
  ///
  /// [`workspace/willCreateFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_willCreateFiles
  ///
  /// The request can return a [`WorkspaceEdit`] which will be applied to
  /// workspace before the files are created. Please note that clients might
  /// drop results if computing the edit took too long or if a server
  /// constantly fails on this request. This is done to keep creates fast
  /// and reliable.
  ///
  /// # Compatibility
  ///
  /// This request was introduced in specification version 3.16.0.
  fn will_create_files(
    &self,
    params: CreateFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = jsonrpc::Result<Option<WorkspaceEdit>>> + Send
  {
    async move {
      otel::span!(
        "laburnum.lsp.will_create_files",
        "files.count" = params.files.len() as i64
      );
      let _ = params;

      Err(jsonrpc::Error::method_not_found())
    }
  }
  const WILL_CREATE_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/willRenameFiles`] request is sent from the client to the
  /// server before files are actually renamed as long as the rename is
  /// triggered from within the client.
  ///
  /// [`workspace/willRenameFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_willRenameFiles
  ///
  /// The request can return a [`WorkspaceEdit`] which will be applied to
  /// workspace before the files are renamed. Please note that clients might
  /// drop results if computing the edit took too long or if a server
  /// constantly fails on this request. This is done to keep creates fast
  /// and reliable.
  ///
  /// # Compatibility
  ///
  /// This request was introduced in specification version 3.16.0.
  fn will_rename_files(
    &self,
    params: RenameFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = jsonrpc::Result<Option<WorkspaceEdit>>> + Send
  {
    async move {
      otel::span!(
        "laburnum.lsp.will_rename_files",
        "files.count" = params.files.len() as i64
      );
      let _ = params;

      Err(jsonrpc::Error::method_not_found())
    }
  }
  const WILL_RENAME_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;

  /// The [`workspace/willDeleteFiles`] request is sent from the client to the
  /// server before files are actually deleted as long as the deletion is
  /// triggered from within the client either by a user action or by applying
  /// a workspace edit.
  ///
  /// [`workspace/willDeleteFiles`]: https://microsoft.github.io/language-server-protocol/specification#workspace_willDeleteFiles
  ///
  /// The request can return a [`WorkspaceEdit`] which will be applied to
  /// workspace before the files are deleted. Please note that clients might
  /// drop results if computing the edit took too long or if a server
  /// constantly fails on this request. This is done to keep deletions
  /// fast and reliable.
  ///
  /// # Compatibility
  ///
  /// This request was introduced in specification version 3.16.0.
  fn will_delete_files(
    &self,
    params: DeleteFilesParams,
    ctx: &mut TaskContext<P, T>,
    writer: &mut PartitionWriteContextRef<'_, P>,
  ) -> impl std::future::Future<Output = jsonrpc::Result<Option<WorkspaceEdit>>> + Send
  {
    async move {
      otel::span!(
        "laburnum.lsp.will_delete_files",
        "files.count" = params.files.len() as i64
      );
      let _ = params;

      Err(jsonrpc::Error::method_not_found())
    }
  }
  const WILL_DELETE_FILES_LANE: crate::scheduler::lanes::Lane =
    crate::scheduler::lanes::DEFAULT_LANE;
}