mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-08 08:52:12 +00:00
Arnaud Ritti
39f6162c12
A plugin view declared with `location = "services"` (plugin API 1.3, `engines.openidea ^1.3`) shows its tree in the Services tool window, next to Docker and the run configurations. The nodes, the toolbar (acting on one selected node) and their events come from `view-provider`; `viewItem.context` menus give the nodes a right-click menu. The pane beside the tree comes from a new optional export, `service-provider.detail(view, key)` (worlds `plugin-services` / `services`), which returns typed tabs: a message, read-only text or a process log. The IDE switches tabs without calling the plugin. For a log, the UI names only the node and tab (`plugin_service_log`); the host asks the plugin for the pane again and runs its program with the plugin's `process:` grant in the project root, with the arguments of the toggles that are on, streaming its output into the log pane Docker uses until it exits (the exit code is shown), the pane closes or the Services window is hidden. A cancelled request starts nothing, lines are cut at 16 KiB, and revoking the grant or cancelling kills the program and what it started. The log pane moves to `src/ui/LogPane` and drops output that arrives after its source was stopped. The Rust SDK gains `openidea_plugin::services` (`Services`, `Tab`, `Pane`, `ProcessLog`). All components are rebuilt for the WIT change. Closes #1736 Co-authored-by: arnaud-ritti <[email protected]>
830 lines
33 KiB
Rust
830 lines
33 KiB
Rust
//! SDK for OpenIDEA plugins written in Rust (plugin API 1.0).
|
|
//!
|
|
//! ```ignore
|
|
//! use openidea_plugin::{Error, Invocation, Plugin, register_plugin};
|
|
//!
|
|
//! #[derive(Default)]
|
|
//! struct Shout;
|
|
//!
|
|
//! impl Plugin for Shout {
|
|
//! fn run_command(&mut self, id: &str, ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, Error> {
|
|
//! match id {
|
|
//! "shout" => {
|
|
//! let editor = ctx.editor().ok_or("no editor is focused")?;
|
|
//! editor.transform_selections(|s| s.to_uppercase())?;
|
|
//! Ok(None)
|
|
//! }
|
|
//! _ => Err(Error::NotFound(format!("command {id}"))),
|
|
//! }
|
|
//! }
|
|
//! }
|
|
//!
|
|
//! register_plugin!(Shout);
|
|
//! ```
|
|
//!
|
|
//! On `wasm32-wasip2` the [`host`] functions and handles call the IDE through
|
|
//! the `openidea:[email protected]` WIT world. On any other target they call the
|
|
//! [`mock`] host, so plugin logic is tested with plain `cargo test`:
|
|
//!
|
|
//! ```ignore
|
|
//! let host = openidea_plugin::mock::MockHost::install();
|
|
//! host.open_editor("/project/a.txt", "rust", "hi there", &[(0, 0, 0, 2)]);
|
|
//! Shout.run_command("shout", &host.invocation(), None).unwrap();
|
|
//! assert_eq!(host.editor_text(), "HI there");
|
|
//! ```
|
|
//!
|
|
//! Instance memory is a cache: the instance is dropped after a crash or when
|
|
//! idle. Keep what must survive in [`host::storage`].
|
|
//!
|
|
//! Build with `openidea-plugin build` (or `cargo build --release --target
|
|
//! wasm32-wasip2`); see `plugins/README.md`.
|
|
|
|
pub mod host;
|
|
pub mod indexing;
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub mod mock;
|
|
pub mod providers;
|
|
pub mod semantic_tokens;
|
|
pub mod services;
|
|
pub mod syntax;
|
|
pub mod text;
|
|
mod types;
|
|
pub mod views;
|
|
|
|
pub use host::{Invocation, Project, Task, TextEditor};
|
|
pub use types::*;
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod bindings {
|
|
wit_bindgen::generate!({
|
|
world: "plugin",
|
|
path: "wit",
|
|
pub_export_macro: true,
|
|
export_macro_name: "__export_plugin_world",
|
|
default_bindings_module: "openidea_plugin::bindings",
|
|
});
|
|
}
|
|
|
|
/// The `syntax` world: only the `syntax-provider` export, merged with
|
|
/// `plugin` into one component (world `plugin-syntax`).
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod syntax_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "syntax",
|
|
path: "wit",
|
|
pub_export_macro: true,
|
|
export_macro_name: "__export_syntax_world",
|
|
default_bindings_module: "openidea_plugin::syntax_bindings",
|
|
});
|
|
}
|
|
|
|
/// The `editor-providers` world: only the `providers` export, merged with
|
|
/// `plugin` (world `plugin-providers`).
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod providers_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "editor-providers",
|
|
path: "wit",
|
|
pub_export_macro: true,
|
|
export_macro_name: "__export_editor_providers_world",
|
|
default_bindings_module: "openidea_plugin::providers_bindings",
|
|
with: {
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::types,
|
|
},
|
|
});
|
|
}
|
|
|
|
/// The `views-provider` world: only the `view-provider` export, merged with
|
|
/// `plugin` (world `plugin-views`).
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod views_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "views-provider",
|
|
path: "wit",
|
|
pub_export_macro: true,
|
|
export_macro_name: "__export_views_world",
|
|
default_bindings_module: "openidea_plugin::views_bindings",
|
|
with: {
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::types,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::workspace,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::editor,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::invocation,
|
|
},
|
|
});
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod indexing_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "indexing", path: "wit", pub_export_macro: true,
|
|
export_macro_name: "__export_indexing_world",
|
|
default_bindings_module: "openidea_plugin::indexing_bindings",
|
|
with: { "openidea:plugin/[email protected]": crate::bindings::openidea::plugin::types },
|
|
});
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod services_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "services", path: "wit", pub_export_macro: true,
|
|
export_macro_name: "__export_services_world",
|
|
default_bindings_module: "openidea_plugin::services_bindings",
|
|
with: {
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::types,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::workspace,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::editor,
|
|
"openidea:plugin/[email protected]": crate::bindings::openidea::plugin::invocation,
|
|
},
|
|
});
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod semantic_bindings {
|
|
wit_bindgen::generate!({
|
|
world: "semantic-tokens", path: "wit", pub_export_macro: true,
|
|
export_macro_name: "__export_semantic_tokens_world",
|
|
default_bindings_module: "openidea_plugin::semantic_bindings",
|
|
with: { "openidea:plugin/[email protected]": crate::bindings::openidea::plugin::types },
|
|
});
|
|
}
|
|
|
|
/// The plugin API version this SDK targets.
|
|
pub const API_VERSION: &str = "1.3";
|
|
|
|
/// A plugin. One instance lives as long as the plugin's Wasm instance (until
|
|
/// it is disabled, crashes or is reclaimed when idle).
|
|
pub trait Plugin: 'static {
|
|
/// Called once when the instance is created: subscribe to events and
|
|
/// restore state from [`host::storage`]. An error fails the activation.
|
|
fn activate(&mut self, _ctx: &Context) -> Result<(), Error> {
|
|
Ok(())
|
|
}
|
|
|
|
/// Called before the instance is dropped.
|
|
fn deactivate(&mut self) {}
|
|
|
|
/// Runs one of the plugin's commands; `Ok(Some(text))` is shown to the user.
|
|
/// A plain message (`Err("…".into())`, or `?` on a `String` error) is
|
|
/// [`Error::Failed`]; return [`Error::Cancelled`] when the user gave up.
|
|
fn run_command(&mut self, id: &str, ctx: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error>;
|
|
|
|
/// A batch of subscribed events (see [`host::subscribe`]), oldest first.
|
|
fn handle_events(&mut self, _events: &[Event], _ctx: &Invocation) {}
|
|
}
|
|
|
|
/// Exports `T` (a [`Plugin`] + `Default`) as the plugin's component. With
|
|
/// `syntax`, `T` is also a [`syntax::SyntaxProvider`] for its languages.
|
|
#[macro_export]
|
|
macro_rules! register_plugin {
|
|
($plugin:ty $(, $export:ident)* $(,)?) => {
|
|
// Natively (tests) nothing is exported; keep the type "used".
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
const _: fn() -> $plugin = <$plugin as ::core::default::Default>::default;
|
|
#[cfg(target_arch = "wasm32")]
|
|
const _: () = {
|
|
struct __OpenideaComponent;
|
|
$crate::__plugin_exports!($plugin, __OpenideaComponent, $crate::bindings);
|
|
$($crate::__optional_exports!($export, $plugin, __OpenideaComponent);)*
|
|
$crate::bindings::__export_plugin_world!(__OpenideaComponent with_types_in $crate::bindings);
|
|
};
|
|
};
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __optional_exports {
|
|
(providers, $plugin:ty, $component:ident) => {
|
|
$crate::__providers_exports!($plugin, $component);
|
|
};
|
|
(views, $plugin:ty, $component:ident) => {
|
|
$crate::__views_exports!($plugin, $component);
|
|
};
|
|
(indexing, $plugin:ty, $component:ident) => {
|
|
$crate::__indexing_exports!($plugin, $component);
|
|
};
|
|
(semantic_tokens, $plugin:ty, $component:ident) => {
|
|
$crate::__semantic_tokens_exports!($plugin, $component);
|
|
};
|
|
(services, $plugin:ty, $component:ident) => {
|
|
$crate::__services_exports!($plugin, $component);
|
|
};
|
|
(syntax, $plugin:ty, $component:ident) => {
|
|
impl $crate::syntax_bindings::exports::openidea::plugin::syntax_provider::Guest for $component {
|
|
fn highlights(
|
|
language: ::std::string::String,
|
|
text: ::std::string::String,
|
|
) -> ::std::vec::Vec<$crate::syntax_bindings::exports::openidea::plugin::syntax_provider::Token>
|
|
{
|
|
$crate::__rt::highlights::<$plugin>(&language, &text)
|
|
}
|
|
|
|
fn outline(
|
|
language: ::std::string::String,
|
|
text: ::std::string::String,
|
|
) -> ::std::vec::Vec<$crate::syntax_bindings::exports::openidea::plugin::syntax_provider::Symbol>
|
|
{
|
|
$crate::__rt::outline::<$plugin>(&language, &text)
|
|
}
|
|
|
|
fn folding(
|
|
language: ::std::string::String,
|
|
text: ::std::string::String,
|
|
) -> ::std::vec::Vec<$crate::syntax_bindings::exports::openidea::plugin::syntax_provider::Fold>
|
|
{
|
|
$crate::__rt::folding::<$plugin>(&language, &text)
|
|
}
|
|
}
|
|
|
|
$crate::syntax_bindings::__export_syntax_world!($component with_types_in $crate::syntax_bindings);
|
|
};
|
|
}
|
|
|
|
/// `register_plugin!(T, providers)`: `T` is also a [`providers::Providers`].
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __providers_exports {
|
|
($plugin:ty, $component:ident) => {
|
|
impl $crate::providers_bindings::exports::openidea::plugin::providers::Guest for $component {
|
|
fn completion(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
at: $crate::bindings::openidea::plugin::types::Position,
|
|
trigger: ::core::option::Option<::std::string::String>,
|
|
) -> ::std::vec::Vec<$crate::providers_bindings::exports::openidea::plugin::providers::CompletionItem> {
|
|
$crate::__rt::completion::<$plugin>(doc, at, trigger)
|
|
}
|
|
|
|
fn inline_completion(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
at: $crate::bindings::openidea::plugin::types::Position,
|
|
) -> ::core::option::Option<$crate::providers_bindings::exports::openidea::plugin::providers::InlineSuggestion> {
|
|
$crate::__rt::inline_completion::<$plugin>(doc, at)
|
|
}
|
|
|
|
fn code_actions(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
selection: $crate::bindings::openidea::plugin::types::Range,
|
|
) -> ::std::vec::Vec<$crate::providers_bindings::exports::openidea::plugin::providers::CodeAction> {
|
|
$crate::__rt::code_actions::<$plugin>(doc, selection)
|
|
}
|
|
|
|
fn resolve_code_action(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
action: $crate::providers_bindings::exports::openidea::plugin::providers::CodeAction,
|
|
) -> ::core::result::Result<
|
|
$crate::providers_bindings::exports::openidea::plugin::providers::CodeAction,
|
|
$crate::bindings::openidea::plugin::types::Error,
|
|
> {
|
|
$crate::__rt::resolve_code_action::<$plugin>(doc, action)
|
|
}
|
|
|
|
fn definition(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
at: $crate::bindings::openidea::plugin::types::Position,
|
|
) -> ::std::vec::Vec<$crate::bindings::openidea::plugin::types::Location> {
|
|
$crate::__rt::definition::<$plugin>(doc, at)
|
|
}
|
|
|
|
fn line_markers(
|
|
doc: $crate::providers_bindings::exports::openidea::plugin::providers::Document,
|
|
) -> ::std::vec::Vec<$crate::providers_bindings::exports::openidea::plugin::providers::LineMarker> {
|
|
$crate::__rt::line_markers::<$plugin>(doc)
|
|
}
|
|
}
|
|
|
|
$crate::providers_bindings::__export_editor_providers_world!($component with_types_in $crate::providers_bindings);
|
|
};
|
|
}
|
|
|
|
/// `register_plugin!(T, views)`: `T` is also a [`views::Views`].
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __views_exports {
|
|
($plugin:ty, $component:ident) => {
|
|
impl $crate::views_bindings::exports::openidea::plugin::view_provider::Guest for $component {
|
|
fn render(
|
|
view: ::std::string::String,
|
|
viewport: ::core::option::Option<$crate::views_bindings::openidea::plugin::view_types::Viewport>,
|
|
ctx: &$crate::bindings::openidea::plugin::invocation::Invocation,
|
|
) -> ::core::result::Result<
|
|
$crate::views_bindings::openidea::plugin::view_types::View,
|
|
$crate::bindings::openidea::plugin::types::Error,
|
|
> {
|
|
$crate::__rt::render_view::<$plugin>(view, viewport, ctx)
|
|
}
|
|
|
|
fn handle(
|
|
view: ::std::string::String,
|
|
event: $crate::views_bindings::openidea::plugin::view_types::ViewEvent,
|
|
ctx: &$crate::bindings::openidea::plugin::invocation::Invocation,
|
|
) -> ::core::result::Result<(), $crate::bindings::openidea::plugin::types::Error> {
|
|
$crate::__rt::view_event::<$plugin>(view, event, ctx)
|
|
}
|
|
}
|
|
|
|
$crate::views_bindings::__export_views_world!($component with_types_in $crate::views_bindings);
|
|
};
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __indexing_exports {
|
|
($plugin:ty, $component:ident) => {
|
|
impl $crate::indexing_bindings::exports::openidea::plugin::document_indexer::Guest for $component {
|
|
fn index(doc: $crate::indexing_bindings::exports::openidea::plugin::document_indexer::Document)
|
|
-> $crate::indexing_bindings::exports::openidea::plugin::document_indexer::Edges {
|
|
$crate::__rt::index_document::<$plugin>(doc)
|
|
}
|
|
}
|
|
$crate::indexing_bindings::__export_indexing_world!($component with_types_in $crate::indexing_bindings);
|
|
};
|
|
}
|
|
|
|
/// `register_plugin!(T, services)`: `T` is also a [`services::Services`].
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __services_exports {
|
|
($plugin:ty, $component:ident) => {
|
|
impl $crate::services_bindings::exports::openidea::plugin::service_provider::Guest for $component {
|
|
fn detail(
|
|
view: ::std::string::String,
|
|
key: ::std::string::String,
|
|
ctx: &$crate::bindings::openidea::plugin::invocation::Invocation,
|
|
) -> ::core::result::Result<
|
|
::std::vec::Vec<$crate::services_bindings::openidea::plugin::service_types::Tab>,
|
|
$crate::bindings::openidea::plugin::types::Error,
|
|
> {
|
|
$crate::__rt::service_detail::<$plugin>(view, key, ctx)
|
|
}
|
|
}
|
|
$crate::services_bindings::__export_services_world!($component with_types_in $crate::services_bindings);
|
|
};
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __semantic_tokens_exports {
|
|
($plugin:ty, $component:ident) => {
|
|
impl $crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider::Guest for $component {
|
|
fn semantic_tokens(
|
|
doc: $crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider::Document,
|
|
) -> ::std::vec::Vec<
|
|
$crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider::SemanticToken,
|
|
> {
|
|
$crate::__rt::semantic_tokens::<$plugin>(doc)
|
|
}
|
|
}
|
|
$crate::semantic_bindings::__export_semantic_tokens_world!($component with_types_in $crate::semantic_bindings);
|
|
};
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! __plugin_exports {
|
|
($plugin:ty, $component:ident, $b:path) => {
|
|
impl $crate::bindings::exports::openidea::plugin::lifecycle::Guest for $component {
|
|
fn activate(
|
|
ctx: $crate::bindings::openidea::plugin::types::Context,
|
|
) -> ::core::result::Result<(), $crate::bindings::openidea::plugin::types::Error> {
|
|
$crate::__rt::activate::<$plugin>(ctx)
|
|
}
|
|
|
|
fn deactivate() {
|
|
$crate::__rt::deactivate::<$plugin>()
|
|
}
|
|
}
|
|
|
|
impl $crate::bindings::exports::openidea::plugin::commands::Guest for $component {
|
|
fn run(
|
|
id: ::std::string::String,
|
|
ctx: &$crate::bindings::openidea::plugin::invocation::Invocation,
|
|
arg: ::core::option::Option<::std::string::String>,
|
|
) -> ::core::result::Result<
|
|
::core::option::Option<::std::string::String>,
|
|
$crate::bindings::openidea::plugin::types::Error,
|
|
> {
|
|
$crate::__rt::run_command::<$plugin>(id, ctx, arg)
|
|
}
|
|
}
|
|
|
|
impl $crate::bindings::exports::openidea::plugin::event_handler::Guest for $component {
|
|
fn handle(
|
|
events: ::std::vec::Vec<$crate::bindings::openidea::plugin::events::Event>,
|
|
ctx: &$crate::bindings::openidea::plugin::invocation::Invocation,
|
|
) {
|
|
$crate::__rt::handle_events::<$plugin>(events, ctx)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
#[doc(hidden)]
|
|
pub mod __rt {
|
|
//! The single plugin instance behind the exports.
|
|
use super::syntax::SyntaxProvider;
|
|
use super::{Context, Invocation, Plugin};
|
|
use crate::bindings::openidea::plugin as b;
|
|
use crate::syntax_bindings::exports::openidea::plugin::syntax_provider as wit;
|
|
use std::any::Any;
|
|
use std::cell::RefCell;
|
|
|
|
thread_local! {
|
|
static INSTANCE: RefCell<Option<Box<dyn Any>>> = const { RefCell::new(None) };
|
|
}
|
|
|
|
fn with<T: Plugin + Default, R>(f: impl FnOnce(&mut T) -> R) -> R {
|
|
INSTANCE.with(|cell| {
|
|
let mut slot = cell.borrow_mut();
|
|
let plugin = slot.get_or_insert_with(|| Box::new(T::default()));
|
|
f(plugin.downcast_mut::<T>().expect("one plugin type per component"))
|
|
})
|
|
}
|
|
|
|
pub fn activate<T: Plugin + Default>(ctx: b::types::Context) -> Result<(), b::types::Error> {
|
|
let ctx = Context {
|
|
plugin_id: ctx.plugin_id,
|
|
plugin_version: ctx.plugin_version,
|
|
api_version: ctx.api_version,
|
|
capabilities: ctx.capabilities,
|
|
};
|
|
with::<T, _>(|p| p.activate(&ctx)).map_err(error_out)
|
|
}
|
|
|
|
pub fn deactivate<T: Plugin + Default>() {
|
|
with::<T, _>(|p| p.deactivate());
|
|
INSTANCE.with(|cell| cell.borrow_mut().take());
|
|
}
|
|
|
|
pub fn run_command<T: Plugin + Default>(
|
|
id: String,
|
|
ctx: &b::invocation::Invocation,
|
|
arg: Option<String>,
|
|
) -> Result<Option<String>, b::types::Error> {
|
|
let ctx = Invocation::__new(ctx);
|
|
with::<T, _>(|p| p.run_command(&id, &ctx, arg.as_deref())).map_err(error_out)
|
|
}
|
|
|
|
// ---- providers ----
|
|
|
|
use crate::providers as p;
|
|
use crate::providers_bindings::exports::openidea::plugin::providers as w;
|
|
|
|
fn doc(d: w::Document) -> p::Document {
|
|
p::Document { path: d.path, language: d.language, version: d.version, text: d.text }
|
|
}
|
|
|
|
fn at(p: b::types::Position) -> crate::Position {
|
|
crate::Position::new(p.line, p.character)
|
|
}
|
|
|
|
fn loc(l: crate::Location) -> b::types::Location {
|
|
b::types::Location { path: l.path, range: crate::host::__range_to(l.range) }
|
|
}
|
|
|
|
pub fn completion<T: Plugin + p::Providers + Default>(
|
|
d: w::Document,
|
|
pos: b::types::Position,
|
|
trigger: Option<String>,
|
|
) -> Vec<w::CompletionItem> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.completion(&d, at(pos), trigger.as_deref()))
|
|
.into_iter()
|
|
.map(|i| w::CompletionItem {
|
|
label: i.label,
|
|
detail: i.detail,
|
|
kind: i.kind.map(|k| k.as_str().to_owned()),
|
|
insert_text: i.insert_text,
|
|
snippet: i.snippet,
|
|
replace: i.replace.map(crate::host::__range_to),
|
|
sort_text: i.sort_text,
|
|
filter_text: i.filter_text,
|
|
documentation: i.documentation,
|
|
additional_edits: i.additional_edits.into_iter().map(edit_out).collect(),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn inline_completion<T: Plugin + p::Providers + Default>(
|
|
d: w::Document,
|
|
pos: b::types::Position,
|
|
) -> Option<w::InlineSuggestion> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.inline_completion(&d, at(pos))).map(|s| w::InlineSuggestion {
|
|
insert_text: s.insert_text,
|
|
replace: s.replace.map(crate::host::__range_to),
|
|
})
|
|
}
|
|
|
|
pub fn code_actions<T: Plugin + p::Providers + Default>(
|
|
d: w::Document,
|
|
sel: b::types::Range,
|
|
) -> Vec<w::CodeAction> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.code_actions(&d, crate::host::__range_from(sel))).into_iter().map(action_out).collect()
|
|
}
|
|
|
|
pub fn resolve_code_action<T: Plugin + p::Providers + Default>(
|
|
d: w::Document,
|
|
action: w::CodeAction,
|
|
) -> Result<w::CodeAction, b::types::Error> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.resolve_code_action(&d, action_in(action))).map(action_out).map_err(error_out)
|
|
}
|
|
|
|
fn edit_out(e: crate::TextEdit) -> b::types::TextEdit {
|
|
b::types::TextEdit { range: crate::host::__range_to(e.range), text: e.text }
|
|
}
|
|
|
|
fn action_out(a: p::CodeAction) -> w::CodeAction {
|
|
w::CodeAction {
|
|
title: a.title,
|
|
kind: a.kind,
|
|
preferred: a.preferred,
|
|
edits: a
|
|
.edits
|
|
.into_iter()
|
|
.map(|(path, edits)| w::FileEdit { path, edits: edits.into_iter().map(edit_out).collect() })
|
|
.collect(),
|
|
data: a.data,
|
|
}
|
|
}
|
|
|
|
fn action_in(a: w::CodeAction) -> p::CodeAction {
|
|
p::CodeAction {
|
|
title: a.title,
|
|
kind: a.kind,
|
|
preferred: a.preferred,
|
|
edits: a
|
|
.edits
|
|
.into_iter()
|
|
.map(|f| {
|
|
let edits = f
|
|
.edits
|
|
.into_iter()
|
|
.map(|e| crate::TextEdit { range: crate::host::__range_from(e.range), text: e.text })
|
|
.collect();
|
|
(f.path, edits)
|
|
})
|
|
.collect(),
|
|
data: a.data,
|
|
}
|
|
}
|
|
|
|
pub fn definition<T: Plugin + p::Providers + Default>(
|
|
d: w::Document,
|
|
pos: b::types::Position,
|
|
) -> Vec<b::types::Location> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.definition(&d, at(pos))).into_iter().map(loc).collect()
|
|
}
|
|
|
|
pub fn line_markers<T: Plugin + p::Providers + Default>(d: w::Document) -> Vec<w::LineMarker> {
|
|
let d = doc(d);
|
|
with::<T, _>(|x| x.line_markers(&d))
|
|
.into_iter()
|
|
.map(|m| w::LineMarker { line: m.line, icon: m.icon, tooltip: m.tooltip, target: m.target.map(loc) })
|
|
.collect()
|
|
}
|
|
|
|
pub fn index_document<T: Plugin + crate::indexing::DocumentIndexer + Default>(
|
|
d: crate::indexing_bindings::exports::openidea::plugin::document_indexer::Document,
|
|
) -> crate::indexing_bindings::exports::openidea::plugin::document_indexer::Edges {
|
|
use crate::indexing as i;
|
|
use crate::indexing_bindings::exports::openidea::plugin::document_indexer as w;
|
|
let doc = i::Document {
|
|
path: d.path,
|
|
text: d.text,
|
|
symbols: d
|
|
.symbols
|
|
.into_iter()
|
|
.map(|s| i::Symbol {
|
|
name: s.name,
|
|
kind: s.kind,
|
|
container: s.container,
|
|
range: crate::host::__range_from(s.range),
|
|
})
|
|
.collect(),
|
|
};
|
|
let e = with::<T, _>(|p| p.index(&doc));
|
|
fn anchor(a: i::Anchor) -> w::Anchor {
|
|
w::Anchor { key: a.key, range: crate::host::__range_to(a.range) }
|
|
}
|
|
w::Edges {
|
|
definitions: e.definitions.into_iter().map(anchor).collect(),
|
|
references: e.references.into_iter().map(anchor).collect(),
|
|
aliases: e.aliases.into_iter().map(|a| w::Alias { prefix: a.prefix, target: a.target }).collect(),
|
|
markers: e.markers.into_iter().map(anchor).collect(),
|
|
}
|
|
}
|
|
|
|
pub fn semantic_tokens<T: Plugin + crate::semantic_tokens::SemanticTokens + Default>(
|
|
d: crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider::Document,
|
|
) -> Vec<crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider::SemanticToken> {
|
|
use crate::semantic_bindings::exports::openidea::plugin::semantic_tokens_provider as w;
|
|
let doc = crate::providers::Document { path: d.path, language: d.language, version: d.version, text: d.text };
|
|
with::<T, _>(|p| p.semantic_tokens(&doc))
|
|
.into_iter()
|
|
.map(|t| w::SemanticToken {
|
|
range: crate::host::__range_to(t.range),
|
|
kind: t.kind.as_str().into(),
|
|
modifiers: t.modifiers.into_iter().map(|m| m.as_str().into()).collect(),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
// ---- views ----
|
|
|
|
use crate::views as v;
|
|
use crate::views_bindings::openidea::plugin::view_types as vt;
|
|
|
|
fn error_out(e: crate::Error) -> b::types::Error {
|
|
use b::types::Error as E;
|
|
match e {
|
|
crate::Error::Denied(c) => E::Denied(c),
|
|
crate::Error::Stale => E::Stale,
|
|
crate::Error::NotFound(m) => E::NotFound(m),
|
|
crate::Error::Invalid(m) => E::Invalid(m),
|
|
crate::Error::Cancelled => E::Cancelled,
|
|
crate::Error::Failed(m) => E::Failed(m),
|
|
}
|
|
}
|
|
|
|
fn view_out(view: v::View) -> vt::View {
|
|
let body = match view.body {
|
|
v::Body::Message(m) => vt::Body::Message(m),
|
|
v::Body::Tree(items) => vt::Body::Tree(
|
|
items
|
|
.into_iter()
|
|
.map(|i| vt::TreeItem {
|
|
key: i.key,
|
|
parent: i.parent,
|
|
label: i.label,
|
|
icon: i.icon,
|
|
detail: i.detail,
|
|
expandable: i.expandable,
|
|
expanded: i.expanded,
|
|
})
|
|
.collect(),
|
|
),
|
|
v::Body::List(items) => vt::Body::List(
|
|
items
|
|
.into_iter()
|
|
.map(|i| vt::ListItem { key: i.key, label: i.label, icon: i.icon, detail: i.detail })
|
|
.collect(),
|
|
),
|
|
v::Body::Form(fields) => vt::Body::Form(
|
|
fields
|
|
.into_iter()
|
|
.map(|f| vt::Field {
|
|
key: f.key,
|
|
label: f.label,
|
|
value: match f.value {
|
|
v::FieldValue::Text(t) => vt::FieldValue::Text(t),
|
|
v::FieldValue::Multiline(t) => vt::FieldValue::Multiline(t),
|
|
v::FieldValue::Checkbox(c) => vt::FieldValue::Checkbox(c),
|
|
v::FieldValue::Choice(o, s) => vt::FieldValue::Choice((o, s)),
|
|
v::FieldValue::Other { kind, data } => {
|
|
vt::FieldValue::Other(b::types::Extension { kind, data })
|
|
}
|
|
},
|
|
})
|
|
.collect(),
|
|
),
|
|
v::Body::Table(t) => vt::Body::Table(vt::Table {
|
|
columns: t.columns,
|
|
total_rows: t.total_rows,
|
|
first_row: t.first_row,
|
|
rows: t.rows,
|
|
editable: t.editable,
|
|
}),
|
|
v::Body::Html(h) => vt::Body::Html(h),
|
|
v::Body::Other { kind, data } => vt::Body::Other(b::types::Extension { kind, data }),
|
|
};
|
|
vt::View {
|
|
toolbar: view
|
|
.toolbar
|
|
.into_iter()
|
|
.map(|b| vt::Button { id: b.id, label: b.label, icon: b.icon, enabled: b.enabled })
|
|
.collect(),
|
|
body,
|
|
status: view.status,
|
|
}
|
|
}
|
|
|
|
pub fn render_view<T: Plugin + v::Views + Default>(
|
|
view: String,
|
|
viewport: Option<vt::Viewport>,
|
|
ctx: &b::invocation::Invocation,
|
|
) -> Result<vt::View, b::types::Error> {
|
|
let ctx = Invocation::__new(ctx);
|
|
let viewport = viewport.map(|v| v::Viewport { first_row: v.first_row, rows: v.rows });
|
|
with::<T, _>(|p| p.render(&view, viewport, &ctx)).map(view_out).map_err(error_out)
|
|
}
|
|
|
|
pub fn service_detail<T: Plugin + crate::services::Services + Default>(
|
|
view: String,
|
|
key: String,
|
|
ctx: &b::invocation::Invocation,
|
|
) -> Result<Vec<crate::services_bindings::openidea::plugin::service_types::Tab>, b::types::Error> {
|
|
use crate::services as s;
|
|
use crate::services_bindings::openidea::plugin::service_types as w;
|
|
let ctx = Invocation::__new(ctx);
|
|
let tab = |t: s::Tab| w::Tab {
|
|
id: t.id,
|
|
label: t.label,
|
|
body: match t.body {
|
|
s::Pane::Message(m) => w::Pane::Message(m),
|
|
s::Pane::Text(text) => w::Pane::Text(text),
|
|
s::Pane::Log(log) => w::Pane::Log(w::ProcessLog {
|
|
program: log.program,
|
|
args: log.args,
|
|
toggles: log
|
|
.toggles
|
|
.into_iter()
|
|
.map(|t| w::LogToggle { id: t.id, label: t.label, args: t.args })
|
|
.collect(),
|
|
}),
|
|
},
|
|
};
|
|
with::<T, _>(|p| p.detail(&view, &key, &ctx)).map(|tabs| tabs.into_iter().map(tab).collect()).map_err(error_out)
|
|
}
|
|
|
|
pub fn view_event<T: Plugin + v::Views + Default>(
|
|
view: String,
|
|
event: vt::ViewEvent,
|
|
ctx: &b::invocation::Invocation,
|
|
) -> Result<(), b::types::Error> {
|
|
let ctx = Invocation::__new(ctx);
|
|
let event = match event {
|
|
vt::ViewEvent::Button(id) => v::ViewEvent::Button(id),
|
|
vt::ViewEvent::Activate(k) => v::ViewEvent::Activate(k),
|
|
vt::ViewEvent::Select(k) => v::ViewEvent::Select(k),
|
|
vt::ViewEvent::Expand(k) => v::ViewEvent::Expand(k),
|
|
vt::ViewEvent::Collapse(k) => v::ViewEvent::Collapse(k),
|
|
vt::ViewEvent::Field((k, value)) => v::ViewEvent::Field(k, value),
|
|
vt::ViewEvent::Cell(c) => v::ViewEvent::Cell { row: c.row, column: c.column, value: c.value },
|
|
vt::ViewEvent::InsertRow(r) => v::ViewEvent::InsertRow(r),
|
|
vt::ViewEvent::DeleteRows(r) => v::ViewEvent::DeleteRows(r),
|
|
vt::ViewEvent::Message(m) => v::ViewEvent::Message(m),
|
|
vt::ViewEvent::Other(x) => v::ViewEvent::Other { kind: x.kind, data: x.data },
|
|
};
|
|
with::<T, _>(|p| p.handle(&view, event, &ctx)).map_err(error_out)
|
|
}
|
|
|
|
pub fn handle_events<T: Plugin + Default>(events: Vec<b::events::Event>, ctx: &b::invocation::Invocation) {
|
|
let events: Vec<crate::Event> = events.into_iter().map(crate::host::__event).collect();
|
|
let ctx = Invocation::__new(ctx);
|
|
with::<T, _>(|p| p.handle_events(&events, &ctx))
|
|
}
|
|
|
|
fn offset(n: usize) -> u32 {
|
|
u32::try_from(n).unwrap_or(u32::MAX)
|
|
}
|
|
|
|
pub fn highlights<T: Plugin + SyntaxProvider + Default>(language: &str, text: &str) -> Vec<wit::Token> {
|
|
with::<T, _>(|p| p.highlights(language, text))
|
|
.into_iter()
|
|
.map(|t| wit::Token { start: offset(t.range.start), end: offset(t.range.end), kind: t.kind.name().into() })
|
|
.collect()
|
|
}
|
|
|
|
pub fn outline<T: Plugin + SyntaxProvider + Default>(language: &str, text: &str) -> Vec<wit::Symbol> {
|
|
with::<T, _>(|p| p.outline(language, text))
|
|
.into_iter()
|
|
.map(|s| wit::Symbol {
|
|
name: s.name,
|
|
detail: s.detail,
|
|
kind: s.kind.name().into(),
|
|
start: offset(s.range.start),
|
|
end: offset(s.range.end),
|
|
name_start: offset(s.name_range.start),
|
|
name_end: offset(s.name_range.end),
|
|
parent: s.parent.map(offset),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn folding<T: Plugin + SyntaxProvider + Default>(language: &str, text: &str) -> Vec<wit::Fold> {
|
|
with::<T, _>(|p| p.folding(language, text))
|
|
.into_iter()
|
|
.map(|f| wit::Fold {
|
|
start_line: f.start_line,
|
|
end_line: f.end_line,
|
|
kind: match f.kind {
|
|
super::syntax::FoldKind::Region => "region",
|
|
super::syntax::FoldKind::Comment => "comment",
|
|
super::syntax::FoldKind::Imports => "imports",
|
|
}
|
|
.into(),
|
|
})
|
|
.collect()
|
|
}
|
|
}
|