gem-graph/gem-graph-client
gem-graph
/
gem-graph-client
3
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Activity
gem-graph-client/libide/lsp/ide-lsp-hover-provider.c

495 lines
14 KiB
C
Raw Blame History

/* ide-lsp-hover-provider.c
*
* Copyright 2018-2019 Christian Hergert <chergert@redhat.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#define G_LOG_DOMAIN "ide-lsp-hover-provider"
#include "config.h"
#include <jsonrpc-glib.h>
#include <libide-code.h>
#include <libide-sourceview.h>
#include <libide-threading.h>
#include "ide-lsp-hover-provider.h"
/**
* SECTION:ide-lsp-hover-provider
* @title: IdeLspHoverProvider
* @short_description: Interactive hover integration for language servers
*
* The #IdeLspHoverProvider provides integration with language servers
* that support hover requests. This can display markup in the interactive
* tooltip that is displayed in the editor.
*
* Since: 3.30
*/
typedef struct
{
IdeLspClient *client;
gchar *category;
gint priority;
} IdeLspHoverProviderPrivate;
static void hover_provider_iface_init (IdeHoverProviderInterface *iface);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (IdeLspHoverProvider,
ide_lsp_hover_provider,
IDE_TYPE_OBJECT,
G_ADD_PRIVATE (IdeLspHoverProvider)
G_IMPLEMENT_INTERFACE (IDE_TYPE_HOVER_PROVIDER, hover_provider_iface_init))
enum {
PROP_0,
PROP_CATEGORY,
PROP_CLIENT,
PROP_PRIORITY,
N_PROPS
};
static GParamSpec *properties [N_PROPS];
static IdeMarkedContent *
parse_marked_string (GVariant *v)
{
g_autoptr(GString) gstr = g_string_new (NULL);
g_autoptr(GVariant) child = NULL;
GVariant *item;
GVariantIter iter;
g_assert (v != NULL);
/*
* @v can be (MarkedString | MarkedString[] | MarkupContent)
*
* MarkedString is (string | { language: string, value: string })
*/
if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
{
gsize len = 0;
const gchar *str = g_variant_get_string (v, &len);
if (str && *str == '\0')
return NULL;
return ide_marked_content_new_from_data (str, len, IDE_MARKED_KIND_PLAINTEXT);
}
if (g_variant_is_of_type (v, G_VARIANT_TYPE_VARIANT))
v = child = g_variant_get_variant (v);
if (g_variant_is_of_type (v, G_VARIANT_TYPE_DICTIONARY))
{
const gchar *value = "";
g_variant_lookup (v, "value", "&s", &value);
if (!ide_str_empty0 (value))
g_string_append_printf (gstr, "%s", value);
}
else
{
g_variant_iter_init (&iter, v);
while ((item = g_variant_iter_next_value (&iter)))
{
GVariant *asv = item;
g_autoptr(GVariant) child2 = NULL;
if (g_variant_is_of_type (item, G_VARIANT_TYPE_VARIANT))
asv = child2 = g_variant_get_variant (item);
if (g_variant_is_of_type (asv, G_VARIANT_TYPE_STRING))
g_string_append (gstr, g_variant_get_string (asv, NULL));
else if (g_variant_is_of_type (asv, G_VARIANT_TYPE_VARDICT))
{
const gchar *lang = "";
const gchar *value = "";
g_variant_lookup (asv, "language", "&s", &lang);
g_variant_lookup (asv, "value", "&s", &value);
#if 0
if (!ide_str_empty0 (lang) && !ide_str_empty0 (value))
g_string_append_printf (str, "```%s\n%s\n```", lang, value);
else if (!ide_str_empty0 (value))
g_string_append (str, value);
#else
if (!ide_str_empty0 (value))
g_string_append_printf (gstr, "```\n%s\n```\n", value);
#endif
}
g_variant_unref (item);
}
}
if (gstr->len)
{
while (g_ascii_isspace(gstr->str[gstr->len]))
g_string_erase (gstr, gstr->len - 1, 1);
return ide_marked_content_new_from_data (gstr->str, gstr->len, IDE_MARKED_KIND_MARKDOWN);
}
return NULL;
}
static void
ide_lsp_hover_provider_dispose (GObject *object)
{
IdeLspHoverProvider *self = (IdeLspHoverProvider *)object;
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
IDE_ENTRY;
g_clear_object (&priv->client);
g_clear_pointer (&priv->category, g_free);
G_OBJECT_CLASS (ide_lsp_hover_provider_parent_class)->dispose (object);
IDE_EXIT;
}
static void
ide_lsp_hover_provider_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
IdeLspHoverProvider *self = IDE_LSP_HOVER_PROVIDER (object);
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
switch (prop_id)
{
case PROP_CATEGORY:
g_value_set_string (value, priv->category);
break;
case PROP_CLIENT:
g_value_set_object (value, ide_lsp_hover_provider_get_client (self));
break;
case PROP_PRIORITY:
g_value_set_int (value, priv->priority);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ide_lsp_hover_provider_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
IdeLspHoverProvider *self = IDE_LSP_HOVER_PROVIDER (object);
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
switch (prop_id)
{
case PROP_CATEGORY:
g_free (priv->category);
priv->category = g_value_dup_string (value);
break;
case PROP_CLIENT:
ide_lsp_hover_provider_set_client (self, g_value_get_object (value));
break;
case PROP_PRIORITY:
priv->priority = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ide_lsp_hover_provider_class_init (IdeLspHoverProviderClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = ide_lsp_hover_provider_dispose;
object_class->get_property = ide_lsp_hover_provider_get_property;
object_class->set_property = ide_lsp_hover_provider_set_property;
/**
* IdeLspHoverProvider:client:
*
* The "client" property is the #IdeLspClient that should be used to
* communicate with the Language Server peer process.
*
* Since: 3.30
*/
properties [PROP_CLIENT] =
g_param_spec_object ("client",
"Client",
"The client to communicate with",
IDE_TYPE_LSP_CLIENT,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
/**
* IdeLspHoverProvider:category:
*
* The "category" property is the category name to use when displaying
* the hover contents.
*
* Since: 3.30
*/
properties [PROP_CATEGORY] =
g_param_spec_string ("category",
"Category",
"The category to display in the hover popover",
NULL,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_PRIORITY] =
g_param_spec_int ("priority",
"Priority",
"Priority for hover content",
G_MININT,
G_MAXINT,
0,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_properties (object_class, N_PROPS, properties);
}
static void
ide_lsp_hover_provider_init (IdeLspHoverProvider *self)
{
}
static void
ide_lsp_hover_provider_hover_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeLspClient *client = (IdeLspClient *)object;
IdeLspHoverProvider *self;
IdeLspHoverProviderPrivate *priv;
g_autoptr(GVariant) reply = NULL;
g_autoptr(GVariant) contents = NULL;
g_autoptr(IdeMarkedContent) marked = NULL;
g_autoptr(IdeTask) task = user_data;
g_autoptr(GError) error = NULL;
IdeHoverContext *context;
IDE_ENTRY;
g_assert (IDE_IS_LSP_CLIENT (client));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (IDE_IS_TASK (task));
self = ide_task_get_source_object (task);
priv = ide_lsp_hover_provider_get_instance_private (self);
g_assert (IDE_IS_LSP_HOVER_PROVIDER (self));
if (!ide_lsp_client_call_finish (client, result, &reply, &error))
{
ide_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!g_variant_is_of_type (reply, G_VARIANT_TYPE_VARDICT) ||
!(contents = g_variant_lookup_value (reply, "contents", NULL)))
{
ide_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Expected 'contents' in reply");
IDE_EXIT;
}
if (!(marked = parse_marked_string (contents)))
{
ide_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Unusable contents from language server");
IDE_EXIT;
}
context = ide_task_get_task_data (task);
g_assert (context != NULL);
g_assert (IDE_IS_HOVER_CONTEXT (context));
ide_hover_context_add_content (context,
priv->priority,
priv->category,
marked);
ide_task_return_boolean (task, TRUE);
IDE_EXIT;
}
static void
ide_lsp_hover_provider_hover_async (IdeHoverProvider *provider,
IdeHoverContext *context,
const GtkTextIter *iter,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeLspHoverProvider *self = (IdeLspHoverProvider *)provider;
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
g_autoptr(IdeTask) task = NULL;
g_autoptr(GVariant) params = NULL;
g_autofree gchar *uri = NULL;
IdeBuffer *buffer;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (IDE_IS_LSP_HOVER_PROVIDER (self));
g_assert (IDE_IS_HOVER_CONTEXT (context));
g_assert (iter != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
task = ide_task_new (self, cancellable, callback, user_data);
ide_task_set_task_data (task, g_object_ref (context), g_object_unref);
ide_task_set_source_tag (task, ide_lsp_hover_provider_hover_async);
if (priv->client == NULL)
{
ide_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_CONNECTED,
"No client to deliver request");
return;
}
buffer = IDE_BUFFER (gtk_text_iter_get_buffer (iter));
uri = ide_buffer_dup_uri (buffer);
line = gtk_text_iter_get_line (iter);
column = gtk_text_iter_get_line_offset (iter);
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (column),
"}"
);
g_assert (IDE_IS_LSP_CLIENT (priv->client));
ide_lsp_client_call_async (priv->client,
"textDocument/hover",
params,
cancellable,
ide_lsp_hover_provider_hover_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static gboolean
ide_lsp_hover_provider_hover_finish (IdeHoverProvider *provider,
GAsyncResult *result,
GError **error)
{
gboolean ret;
IDE_ENTRY;
g_assert (IDE_IS_LSP_HOVER_PROVIDER (provider));
g_assert (IDE_IS_TASK (result));
ret = ide_task_propagate_boolean (IDE_TASK (result), error);
IDE_RETURN (ret);
}
static void
ide_lsp_hover_provider_real_load (IdeHoverProvider *provider,
IdeSourceView *view)
{
IdeLspHoverProvider *self = (IdeLspHoverProvider *)provider;
IDE_ENTRY;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (IDE_IS_LSP_HOVER_PROVIDER (self));
if (IDE_LSP_HOVER_PROVIDER_GET_CLASS (self)->prepare)
IDE_LSP_HOVER_PROVIDER_GET_CLASS (self)->prepare (self);
IDE_EXIT;
}
static void
hover_provider_iface_init (IdeHoverProviderInterface *iface)
{
iface->load = ide_lsp_hover_provider_real_load;
iface->hover_async = ide_lsp_hover_provider_hover_async;
iface->hover_finish = ide_lsp_hover_provider_hover_finish;
}
/**
* ide_lsp_hover_provider_get_client:
* @self: an #IdeLspHoverProvider
*
* Gets the client that is used for communication.
*
* Returns: (transfer none) (nullable): an #IdeLspClient or %NULL
*
* Since: 3.30
*/
IdeLspClient *
ide_lsp_hover_provider_get_client (IdeLspHoverProvider *self)
{
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
g_return_val_if_fail (IDE_IS_LSP_HOVER_PROVIDER (self), NULL);
return priv->client;
}
/**
* ide_lsp_hover_provider_set_client:
* @self: an #IdeLspHoverProvider
* @client: an #IdeLspClient
*
* Sets the client to be used to query for hover information.
*
* Since: 3.30
*/
void
ide_lsp_hover_provider_set_client (IdeLspHoverProvider *self,
IdeLspClient *client)
{
IdeLspHoverProviderPrivate *priv = ide_lsp_hover_provider_get_instance_private (self);
g_return_if_fail (IDE_IS_LSP_HOVER_PROVIDER (self));
g_return_if_fail (!client || IDE_IS_LSP_CLIENT (client));
if (g_set_object (&priv->client, client))
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_CLIENT]);
}
Reference in New Issue View Git Blame Copy Permalink