use crate::Editor; use gpui::{App, Task as AsyncTask, Window};use project::Location;use task::{TaskContext, TaskVariables, VariableName};use text::{ToOffset, ToPoint};use workspace::Workspace; fn task_context_with_editor(    editor: &mut Editor,    window: &mut Window,    cx: &mut App,) -> AsyncTask<Option<TaskContext>> {    let Some(project) = editor.project.clone() else {        return AsyncTask::ready(None);    };    let (selection, buffer, editor_snapshot) = {        let selection = editor.selections.newest_adjusted(cx);        let Some((buffer, _)) = editor            .buffer()            .read(cx)            .point_to_buffer_offset(selection.start, cx)        else {            return AsyncTask::ready(None);        };        let snapshot = editor.snapshot(window, cx);        (selection, buffer, snapshot)    };    let selection_range = selection.range();    let start = editor_snapshot        .display_snapshot        .buffer_snapshot        .anchor_after(selection_range.start)        .text_anchor;    let end = editor_snapshot        .display_snapshot        .buffer_snapshot        .anchor_after(selection_range.end)        .text_anchor;    let location = Location {        buffer,        range: start..end,    };    let captured_variables = {        let mut variables = TaskVariables::default();        let buffer = location.buffer.read(cx);        let buffer_id = buffer.remote_id();        let snapshot = buffer.snapshot();        let starting_point = location.range.start.to_point(&snapshot);        let starting_offset = starting_point.to_offset(&snapshot);        for (_, tasks) in editor            .tasks            .range((buffer_id, 0)..(buffer_id, starting_point.row + 1))        {            if !tasks                .context_range                .contains(&crate::BufferOffset(starting_offset))            {                continue;            }            for (capture_name, value) in tasks.extra_variables.iter() {                variables.insert(                    VariableName::Custom(capture_name.to_owned().into()),                    value.clone(),                );            }        }        variables    };     project.update(cx, |project, cx| {        project.task_store().update(cx, |task_store, cx| {            task_store.task_context_for_location(captured_variables, location, cx)        })    })} pub fn task_context(    workspace: &Workspace,    window: &mut Window,    cx: &mut App,) -> AsyncTask<TaskContext> {    let Some(editor) = workspace        .active_item(cx)        .and_then(|item| item.act_as::<Editor>(cx))    else {        return AsyncTask::ready(TaskContext::default());    };    editor.update(cx, |editor, cx| {        let context_task = task_context_with_editor(editor, window, cx);        cx.background_executor()            .spawn(async move { context_task.await.unwrap_or_default() })    })}