tenant.openagents/omega

1use anyhow::Context as _;
2use gpui::{App, Context, Entity, TaskExt, Window};
3use language::Language;
4use project::lsp_store::lsp_ext_command::SwitchSourceHeaderResult;
5use rpc::proto;
6use url::Url;
7use util::paths::{PathStyle, UrlExt as _};
8use workspace::{OpenOptions, OpenVisible};
9
10use crate::lsp_ext::find_specific_language_server_in_selection;
11
12use crate::{Editor, SwitchSourceHeader, element::register_action};
13
14use project::lsp_store::clangd_ext::CLANGD_SERVER_NAME;
15
16fn is_c_language(language: &Language) -> bool {
17    language.name() == "C++" || language.name() == "C"
18}
19
20pub fn switch_source_header(
21    editor: &mut Editor,
22    _: &SwitchSourceHeader,
23    window: &mut Window,
24    cx: &mut Context<Editor>,
25) {
26    let Some(project) = &editor.project else {
27        return;
28    };
29    let Some(workspace) = editor.workspace() else {
30        return;
31    };
32
33    let Some((_, _, server_to_query, buffer)) =
34        find_specific_language_server_in_selection(editor, cx, is_c_language, CLANGD_SERVER_NAME)
35    else {
36        return;
37    };
38    let project = project.clone();
39    let upstream_client = project.read(cx).lsp_store().read(cx).upstream_client();
40    cx.spawn_in(window, async move |_editor, cx| {
41        let source_file = buffer.read_with(cx, |buffer, _| {
42            buffer
43                .file()
44                .map(|file| file.path())
45                .map(|path| path.display(PathStyle::local()).to_string())
46                .unwrap_or_else(|| "Unknown".to_string())
47        });
48
49        let switch_source_header = if let Some((client, project_id)) = upstream_client {
50            let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());
51            let request = proto::LspExtSwitchSourceHeader {
52                project_id,
53                buffer_id: buffer_id.to_proto(),
54            };
55            let response = client
56                .request(request)
57                .await
58                .context("lsp ext switch source header proto request")?;
59            SwitchSourceHeaderResult(response.target_file)
60        } else {
61            project
62                .update(cx, |project, cx| {
63                    project.request_lsp(
64                        buffer,
65                        project::LanguageServerToQuery::Other(server_to_query),
66                        project::lsp_store::lsp_ext_command::SwitchSourceHeader,
67                        cx,
68                    )
69                })
70                .await
71                .with_context(|| {
72                    format!("Switch source/header LSP request for path \"{source_file}\" failed")
73                })?
74        };
75
76        if switch_source_header.0.is_empty() {
77            return Ok(());
78        }
79        let path_style = workspace.update(cx, |ws, cx| ws.path_style(cx));
80        let path = Url::parse(&switch_source_header.0).with_context(|| {
81            format!(
82                "Parsing URL \"{}\" returned from switch source/header failed",
83                switch_source_header.0
84            )
85        })?;
86        let path = path.to_file_path_ext(path_style).map_err(|()| {
87            anyhow::anyhow!(
88                "URL conversion to file path failed for \"{}\"",
89                switch_source_header.0
90            )
91        })?;
92
93        workspace
94            .update_in(cx, |workspace, window, cx| {
95                workspace.open_abs_path(
96                    path,
97                    OpenOptions {
98                        visible: Some(OpenVisible::None),
99                        ..Default::default()
100                    },
101                    window,
102                    cx,
103                )
104            })
105            .with_context(|| {
106                format!(
107                    "Switch source/header could not open \"{}\" in workspace",
108                    switch_source_header.0
109                )
110            })?
111            .await
112            .map(|_| ())
113    })
114    .detach_and_log_err(cx);
115}
116
117pub fn apply_related_actions(editor: &Entity<Editor>, window: &mut Window, cx: &mut App) {
118    if editor
119        .read(cx)
120        .buffer()
121        .read(cx)
122        .all_buffers()
123        .into_iter()
124        .filter_map(|buffer| buffer.read(cx).language())
125        .any(|language| is_c_language(language))
126    {
127        register_action(editor, window, switch_source_header);
128    }
129}
130