static void
ide_autotools_build_system_get_build_flags_async (IdeBuildSystem *build_system,
IdeFile *file,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self = (IdeAutotoolsBuildSystem *)build_system;
g_autoptr(GTask) task = NULL;
GFile *gfile;
g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
g_assert (IDE_IS_FILE (file));
EGG_COUNTER_INC (build_flags);
gfile = ide_file_get_file (file);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, g_object_ref (gfile), g_object_unref);
ide_autotools_build_system_get_makecache_async (self,
cancellable,
ide_autotools_build_system__makecache_cb,
g_object_ref (task));
}
static void
ide_file_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
IdeFile *self = (IdeFile *)object;
switch (prop_id)
{
case PROP_FILE:
g_value_set_object (value, ide_file_get_file (self));
break;
case PROP_IS_TEMPORARY:
g_value_set_boolean (value, ide_file_get_is_temporary (self));
break;
case PROP_LANGUAGE:
g_value_set_object (value, ide_file_get_language (self));
break;
case PROP_PATH:
g_value_set_string (value, ide_file_get_path (self));
break;
case PROP_TEMPORARY_ID:
g_value_set_uint (value, ide_file_get_temporary_id (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static IdeUnsavedFile *
get_unsaved_file (IdeGettextDiagnosticProvider *self,
IdeFile *file)
{
g_autoptr(GPtrArray) array = NULL;
IdeUnsavedFiles *unsaved_files;
IdeContext *context;
guint i;
g_assert (IDE_IS_GETTEXT_DIAGNOSTIC_PROVIDER (self));
g_assert (IDE_IS_FILE (file));
context = ide_object_get_context (IDE_OBJECT (self));
unsaved_files = ide_context_get_unsaved_files (context);
array = ide_unsaved_files_to_array (unsaved_files);
for (i = 0; i < array->len; i++)
{
IdeUnsavedFile *unsaved_file = g_ptr_array_index (array, i);
GFile *ufile = ide_unsaved_file_get_file (unsaved_file);
GFile *ifile = ide_file_get_file (file);
g_assert (G_IS_FILE (ufile));
g_assert (G_IS_FILE (ifile));
if (g_file_equal (ufile, ifile))
return ide_unsaved_file_ref (unsaved_file);
}
return NULL;
}
void
gb_view_stack_focus_location (GbViewStack *self,
IdeSourceLocation *location)
{
IdeBufferManager *buffer_manager;
IdeBuffer *buffer;
IdeFile *file;
GFile *gfile;
g_return_if_fail (GB_IS_VIEW_STACK (self));
g_return_if_fail (location != NULL);
if (self->context == NULL)
return;
file = ide_source_location_get_file (location);
gfile = ide_file_get_file (file);
g_assert (file != NULL);
g_assert (IDE_IS_FILE (file));
gfile = ide_file_get_file (file);
buffer_manager = ide_context_get_buffer_manager (self->context);
buffer = ide_buffer_manager_find_buffer (buffer_manager, gfile);
if (buffer != NULL && GB_IS_DOCUMENT (buffer))
{
GtkWidget *active_view;
gb_view_stack_focus_document (self, GB_DOCUMENT (buffer));
active_view = gb_view_stack_get_active_view (self);
g_assert (GB_DOCUMENT (buffer) == gb_view_get_document (GB_VIEW (active_view)));
gb_view_navigate_to (GB_VIEW (active_view), location);
}
else
{
g_autoptr(GTask) task = NULL;
task = g_task_new (self, NULL, NULL, NULL);
g_task_set_task_data (task, ide_source_location_ref (location),
(GDestroyNotify)ide_source_location_unref);
ide_buffer_manager_load_file_async (buffer_manager, file, FALSE, NULL, NULL,
gb_view_stack__navigate_to_load_cb,
g_object_ref (task));
}
}
static void
ide_editor_view_actions_save_as (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeBuffer *buffer;
GtkWidget *suggested;
GtkWidget *toplevel;
GtkWidget *dialog;
IdeFile *file;
GFile *gfile;
g_assert (IDE_IS_EDITOR_VIEW (self));
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"do-overwrite-confirmation", TRUE,
"local-only", FALSE,
"modal", TRUE,
"select-multiple", FALSE,
"show-hidden", FALSE,
"transient-for", toplevel,
"title", _("Save Document As"),
NULL);
buffer = IDE_BUFFER (self->document);
file = ide_buffer_get_file (buffer);
gfile = ide_file_get_file (file);
if (gfile != NULL)
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (dialog), gfile, NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
suggested = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (suggested),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
g_signal_connect (dialog, "response", G_CALLBACK (save_as_response), g_object_ref (self));
gtk_window_present (GTK_WINDOW (dialog));
}
/**
* ide_source_location_get_uri:
* @self: (in): an #IdeSourceLocation.
*
* Returns: (transfer full): A newly allocated #IdeUri.
*/
IdeUri *
ide_source_location_get_uri (IdeSourceLocation *self)
{
GFile *file;
IdeUri *ret;
gchar *fragment;
g_return_val_if_fail (self != NULL, NULL);
file = ide_file_get_file (self->file);
ret = ide_uri_new_from_file (file);
fragment = g_strdup_printf ("L%u_%u", self->line, self->line_offset);
ide_uri_set_fragment (ret, fragment);
g_free (fragment);
return ret;
}
static void
ide_git_buffer_change_monitor_calculate_async (IdeGitBufferChangeMonitor *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
DiffTask *diff;
IdeFile *file;
GFile *gfile;
g_assert (IDE_IS_GIT_BUFFER_CHANGE_MONITOR (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (self->buffer != NULL);
g_assert (self->repository != NULL);
self->state_dirty = FALSE;
task = g_task_new (self, cancellable, callback, user_data);
file = ide_buffer_get_file (self->buffer);
gfile = ide_file_get_file (file);
if (!gfile)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
_("Cannot provide diff, no backing file provided."));
return;
}
diff = g_slice_new0 (DiffTask);
diff->file = g_object_ref (gfile);
diff->repository = g_object_ref (self->repository);
diff->state = g_hash_table_new (g_direct_hash, g_direct_equal);
diff->content = ide_buffer_get_content (self->buffer);
diff->blob = self->cached_blob ? g_object_ref (self->cached_blob) : NULL;
g_task_set_task_data (task, diff, diff_task_free);
self->in_calculation = TRUE;
g_async_queue_push (gWorkQueue, g_object_ref (task));
}
static void
gb_editor_view_actions_reveal (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
GbEditorView *self = user_data;
GbWorkbench *workbench;
IdeFile *file;
GFile *gfile;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (GB_IS_EDITOR_VIEW (self));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
gfile = ide_file_get_file (file);
workbench = gb_widget_get_workbench (GTK_WIDGET (self));
gb_workbench_reveal_file (workbench, gfile);
}
static void
find_other_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GbEditorView) self = user_data;
g_autoptr(IdeFile) ret = NULL;
IdeFile *file = (IdeFile *)object;
ret = ide_file_find_other_finish (file, result, NULL);
if (ret != NULL)
{
GbWorkbench *workbench;
GFile *gfile;
gfile = ide_file_get_file (ret);
workbench = gb_widget_get_workbench (GTK_WIDGET (self));
gb_workbench_open (workbench, gfile);
}
}
static void
find_other_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(IdeEditorView) self = user_data;
g_autoptr(IdeFile) ret = NULL;
IdeFile *file = (IdeFile *)object;
ret = ide_file_find_other_finish (file, result, NULL);
if (ret != NULL)
{
IdeWorkbench *workbench;
GFile *gfile;
IdeWorkbenchOpenFlags flags;
gfile = ide_file_get_file (ret);
workbench = ide_widget_get_workbench (GTK_WIDGET (self));
flags = WORKBENCH_OPEN_FLAGS_NONE;
ide_workbench_open_files_async (workbench, &gfile, 1, "editor", flags, NULL, NULL, NULL);
}
}
static void
ide_langserv_rename_provider_rename_async (IdeRenameProvider *provider,
IdeSourceLocation *location,
const gchar *new_name,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeLangservRenameProvider *self = (IdeLangservRenameProvider *)provider;
IdeLangservRenameProviderPrivate *priv = ide_langserv_rename_provider_get_instance_private (self);
g_autoptr(GTask) task = NULL;
g_autoptr(JsonNode) params = NULL;
g_autofree gchar *uri = NULL;
IdeFile *ifile;
GFile *gfile;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_RENAME_PROVIDER (self));
g_assert (location != NULL);
g_assert (new_name != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_langserv_rename_provider_rename_async);
if (priv->client == NULL)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_CONNECTED,
"No client set, cannot rename symbol");
IDE_EXIT;
}
ifile = ide_source_location_get_file (location);
gfile = ide_file_get_file (ifile);
uri = g_file_get_uri (gfile);
line = ide_source_location_get_line (location);
column = ide_source_location_get_line_offset (location);
params = JCON_NEW (
"textDocument", "{",
"uri", JCON_STRING (uri),
"}",
"position", "{",
"line", JCON_INT (line),
"character", JCON_INT (column),
"}",
"newName", JCON_STRING (new_name)
);
ide_langserv_client_call_async (priv->client,
"textDocument/rename",
g_steal_pointer (¶ms),
cancellable,
ide_langserv_rename_provider_rename_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static void
ide_langserv_symbol_resolver_find_references_async (IdeSymbolResolver *resolver,
IdeSourceLocation *location,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeLangservSymbolResolver *self = (IdeLangservSymbolResolver *)resolver;
IdeLangservSymbolResolverPrivate *priv = ide_langserv_symbol_resolver_get_instance_private (self);
g_autoptr(GTask) task = NULL;
g_autoptr(GVariant) params = NULL;
g_autofree gchar *uri = NULL;
const gchar *language_id;
IdeFile *file;
GFile *gfile;
guint line;
guint line_offset;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_SYMBOL_RESOLVER (self));
g_assert (location != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_langserv_symbol_resolver_find_references_async);
file = ide_source_location_get_file (location);
gfile = ide_file_get_file (file);
uri = g_file_get_uri (gfile);
line = ide_source_location_get_line (location);
line_offset = ide_source_location_get_line_offset (location);
language_id = ide_file_get_language_id (file);
if (language_id == NULL)
language_id = "plain";
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"languageId", JSONRPC_MESSAGE_PUT_STRING (language_id),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (line_offset),
"}",
"context", "{",
"includeDeclaration", JSONRPC_MESSAGE_PUT_BOOLEAN (TRUE),
"}"
);
ide_langserv_client_call_async (priv->client,
"textDocument/references",
g_steal_pointer (¶ms),
cancellable,
ide_langserv_symbol_resolver_find_references_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static void
ide_langserv_symbol_resolver_lookup_symbol_async (IdeSymbolResolver *resolver,
IdeSourceLocation *location,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeLangservSymbolResolver *self = (IdeLangservSymbolResolver *)resolver;
IdeLangservSymbolResolverPrivate *priv = ide_langserv_symbol_resolver_get_instance_private (self);
g_autoptr(GTask) task = NULL;
g_autoptr(GVariant) params = NULL;
g_autofree gchar *uri = NULL;
IdeFile *ifile;
GFile *gfile;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_SYMBOL_RESOLVER (self));
g_assert (location != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_langserv_symbol_resolver_lookup_symbol_async);
if (priv->client == NULL)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_CONNECTED,
"%s requires a client to resolve symbols",
G_OBJECT_TYPE_NAME (self));
IDE_EXIT;
}
if (NULL == (ifile = ide_source_location_get_file (location)) ||
NULL == (gfile = ide_file_get_file (ifile)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"Cannot resolve symbol, invalid source location");
IDE_EXIT;
}
uri = g_file_get_uri (gfile);
line = ide_source_location_get_line (location);
column = ide_source_location_get_line_offset (location);
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (column),
"}"
);
ide_langserv_client_call_async (priv->client,
"textDocument/definition",
g_steal_pointer (¶ms),
cancellable,
ide_langserv_symbol_resolver_definition_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static void
ide_clang_service_get_translation_unit_worker (EggTaskCache *cache,
gconstpointer key,
GTask *task,
gpointer user_data)
{
g_autoptr(GTask) real_task = NULL;
IdeClangService *self = user_data;
IdeUnsavedFiles *unsaved_files;
IdeBuildSystem *build_system;
ParseRequest *request;
IdeContext *context;
const gchar *path;
IdeFile *file = (IdeFile *)key;
GFile *gfile;
g_assert (IDE_IS_CLANG_SERVICE (self));
g_assert (IDE_IS_CLANG_SERVICE (self));
g_assert (IDE_IS_FILE (key));
g_assert (IDE_IS_FILE (file));
g_assert (G_IS_TASK (task));
context = ide_object_get_context (IDE_OBJECT (self));
unsaved_files = ide_context_get_unsaved_files (context);
build_system = ide_context_get_build_system (context);
gfile = ide_file_get_file (file);
if (!gfile || !(path = g_file_get_path (gfile)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
_("File must be saved locally to parse."));
return;
}
request = g_slice_new0 (ParseRequest);
request->file = g_object_ref (file);
request->index = self->index;
request->source_filename = g_strdup (path);
request->command_line_args = NULL;
request->unsaved_files = ide_unsaved_files_to_array (unsaved_files);
request->sequence = ide_unsaved_files_get_sequence (unsaved_files);
/*
* NOTE:
*
* I'm torn on this one. It requires a bunch of extra memory, but without it
* we don't get information about macros. And since we need that to provide
* quality highlighting, I'm going try try enabling it for now and see how
* things go.
*/
request->options = (clang_defaultEditingTranslationUnitOptions () |
CXTranslationUnit_DetailedPreprocessingRecord);
real_task = g_task_new (self,
g_task_get_cancellable (task),
ide_clang_service_unit_completed_cb,
g_object_ref (task));
g_task_set_task_data (real_task, request, parse_request_free);
/*
* Request the build flags necessary to build this module from the build system.
*/
IDE_TRACE_MSG ("Requesting build of translation unit");
ide_build_system_get_build_flags_async (build_system,
file,
g_task_get_cancellable (task),
ide_clang_service__get_build_flags_cb,
g_object_ref (real_task));
}
static void
ide_clang_service_parse_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
g_autoptr(IdeClangTranslationUnit) ret = NULL;
g_autoptr(IdeHighlightIndex) index = NULL;
g_autoptr(IdeFile) file_copy = NULL;
IdeClangService *self = source_object;
CXTranslationUnit tu = NULL;
ParseRequest *request = task_data;
IdeContext *context;
const gchar * const *argv;
GFile *gfile;
gsize argc = 0;
const gchar *detail_error = NULL;
enum CXErrorCode code;
GArray *ar = NULL;
gsize i;
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_CLANG_SERVICE (source_object));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (IDE_IS_FILE (request->file));
file_copy = g_object_ref (request->file);
ar = g_array_new (FALSE, FALSE, sizeof (struct CXUnsavedFile));
g_array_set_clear_func (ar, clear_unsaved_file);
for (i = 0; i < request->unsaved_files->len; i++)
{
IdeUnsavedFile *iuf = g_ptr_array_index (request->unsaved_files, i);
struct CXUnsavedFile uf;
GBytes *content;
GFile *file;
file = ide_unsaved_file_get_file (iuf);
content = ide_unsaved_file_get_content (iuf);
uf.Filename = g_file_get_path (file);
uf.Contents = g_bytes_get_data (content, NULL);
uf.Length = g_bytes_get_size (content);
g_array_append_val (ar, uf);
}
argv = (const gchar * const *)request->command_line_args;
argc = argv ? g_strv_length (request->command_line_args) : 0;
EGG_COUNTER_INC (ParseAttempts);
code = clang_parseTranslationUnit2 (request->index,
request->source_filename,
argv, argc,
(struct CXUnsavedFile *)(void *)ar->data,
ar->len,
request->options,
&tu);
switch (code)
{
case CXError_Success:
index = ide_clang_service_build_index (self, tu, request);
#ifdef IDE_ENABLE_TRACE
ide_highlight_index_dump (index);
#endif
break;
case CXError_Failure:
detail_error = _("Unknown failure");
break;
case CXError_Crashed:
detail_error = _("Clang crashed");
break;
case CXError_InvalidArguments:
detail_error = _("Invalid arguments");
break;
case CXError_ASTReadError:
detail_error = _("AST read error");
break;
default:
break;
}
if (!tu)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Failed to create translation unit: %s"),
detail_error ? detail_error : "");
goto cleanup;
}
context = ide_object_get_context (source_object);
gfile = ide_file_get_file (request->file);
ret = _ide_clang_translation_unit_new (context, tu, gfile, index, request->sequence);
g_task_return_pointer (task, g_object_ref (ret), g_object_unref);
cleanup:
g_array_unref (ar);
}
