1use std::fs;
2use zed::lsp::CompletionKind;
3use zed::{
4 CodeLabel, CodeLabelSpan, LanguageServerId, SlashCommand, SlashCommandOutput,
5 SlashCommandOutputSection,
6};
7use zed_extension_api::{self as zed, Result};
8
9struct GleamExtension {
10 cached_binary_path: Option<String>,
11}
12
13impl GleamExtension {
14 fn language_server_binary_path(
15 &mut self,
16 language_server_id: &LanguageServerId,
17 worktree: &zed::Worktree,
18 ) -> Result<String> {
19 if let Some(path) = worktree.which("gleam") {
20 return Ok(path);
21 }
22
23 if let Some(path) = &self.cached_binary_path {
24 if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
25 return Ok(path.clone());
26 }
27 }
28
29 zed::set_language_server_installation_status(
30 &language_server_id,
31 &zed::LanguageServerInstallationStatus::CheckingForUpdate,
32 );
33 let release = zed::latest_github_release(
34 "gleam-lang/gleam",
35 zed::GithubReleaseOptions {
36 require_assets: true,
37 pre_release: false,
38 },
39 )?;
40
41 let (platform, arch) = zed::current_platform();
42 let asset_name = format!(
43 "gleam-{version}-{arch}-{os}.tar.gz",
44 version = release.version,
45 arch = match arch {
46 zed::Architecture::Aarch64 => "aarch64",
47 zed::Architecture::X86 => "x86",
48 zed::Architecture::X8664 => "x86_64",
49 },
50 os = match platform {
51 zed::Os::Mac => "apple-darwin",
52 zed::Os::Linux => "unknown-linux-musl",
53 zed::Os::Windows => "pc-windows-msvc",
54 },
55 );
56
57 let asset = release
58 .assets
59 .iter()
60 .find(|asset| asset.name == asset_name)
61 .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
62
63 let version_dir = format!("gleam-{}", release.version);
64 let binary_path = format!("{version_dir}/gleam");
65
66 if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
67 zed::set_language_server_installation_status(
68 &language_server_id,
69 &zed::LanguageServerInstallationStatus::Downloading,
70 );
71
72 zed::download_file(
73 &asset.download_url,
74 &version_dir,
75 zed::DownloadedFileType::GzipTar,
76 )
77 .map_err(|e| format!("failed to download file: {e}"))?;
78
79 let entries =
80 fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
81 for entry in entries {
82 let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
83 if entry.file_name().to_str() != Some(&version_dir) {
84 fs::remove_dir_all(&entry.path()).ok();
85 }
86 }
87 }
88
89 self.cached_binary_path = Some(binary_path.clone());
90 Ok(binary_path)
91 }
92}
93
94impl zed::Extension for GleamExtension {
95 fn new() -> Self {
96 Self {
97 cached_binary_path: None,
98 }
99 }
100
101 fn language_server_command(
102 &mut self,
103 language_server_id: &LanguageServerId,
104 worktree: &zed::Worktree,
105 ) -> Result<zed::Command> {
106 Ok(zed::Command {
107 command: self.language_server_binary_path(language_server_id, worktree)?,
108 args: vec!["lsp".to_string()],
109 env: Default::default(),
110 })
111 }
112
113 fn label_for_completion(
114 &self,
115 _language_server_id: &LanguageServerId,
116 completion: zed::lsp::Completion,
117 ) -> Option<zed::CodeLabel> {
118 let name = &completion.label;
119 let ty = strip_newlines_from_detail(&completion.detail?);
120 let let_binding = "let a";
121 let colon = ": ";
122 let assignment = " = ";
123 let call = match completion.kind? {
124 CompletionKind::Function | CompletionKind::Constructor => "()",
125 _ => "",
126 };
127 let code = format!("{let_binding}{colon}{ty}{assignment}{name}{call}");
128
129 Some(CodeLabel {
130 spans: vec![
131 CodeLabelSpan::code_range({
132 let start = let_binding.len() + colon.len() + ty.len() + assignment.len();
133 start..start + name.len()
134 }),
135 CodeLabelSpan::code_range({
136 let start = let_binding.len();
137 start..start + colon.len()
138 }),
139 CodeLabelSpan::code_range({
140 let start = let_binding.len() + colon.len();
141 start..start + ty.len()
142 }),
143 ],
144 filter_range: (0..name.len()).into(),
145 code,
146 })
147 }
148
149 fn complete_slash_command_argument(
150 &self,
151 command: SlashCommand,
152 _query: String,
153 ) -> Result<Vec<String>, String> {
154 match command.name.as_str() {
155 "gleam-project" => Ok(vec![
156 "apple".to_string(),
157 "banana".to_string(),
158 "cherry".to_string(),
159 ]),
160 _ => Ok(Vec::new()),
161 }
162 }
163
164 fn run_slash_command(
165 &self,
166 command: SlashCommand,
167 _argument: Option<String>,
168 worktree: &zed::Worktree,
169 ) -> Result<SlashCommandOutput, String> {
170 match command.name.as_str() {
171 "gleam-project" => {
172 let mut text = String::new();
173 text.push_str("You are in a Gleam project.\n");
174
175 if let Some(gleam_toml) = worktree.read_text_file("gleam.toml").ok() {
176 text.push_str("The `gleam.toml` is as follows:\n");
177 text.push_str(&gleam_toml);
178 }
179
180 Ok(SlashCommandOutput {
181 sections: vec![SlashCommandOutputSection {
182 range: (0..text.len()).into(),
183 label: "gleam-project".to_string(),
184 }],
185 text,
186 })
187 }
188 command => Err(format!("unknown slash command: \"{command}\"")),
189 }
190 }
191}
192
193zed::register_extension!(GleamExtension);
194
195/// Removes newlines from the completion detail.
196///
197/// The Gleam LSP can return types containing newlines, which causes formatting
198/// issues within the Zed completions menu.
199fn strip_newlines_from_detail(detail: &str) -> String {
200 let without_newlines = detail
201 .replace("->\n ", "-> ")
202 .replace("\n ", "")
203 .replace(",\n", "");
204
205 let comma_delimited_parts = without_newlines.split(',');
206 comma_delimited_parts
207 .map(|part| part.trim())
208 .collect::<Vec<_>>()
209 .join(", ")
210}
211
212#[cfg(test)]
213mod tests {
214 use crate::strip_newlines_from_detail;
215
216 #[test]
217 fn test_strip_newlines_from_detail() {
218 let detail = "fn(\n Selector(a),\n b,\n fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a,\n) -> Selector(a)";
219 let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
220 assert_eq!(strip_newlines_from_detail(detail), expected);
221
222 let detail = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) ->\n Selector(a)";
223 let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
224 assert_eq!(strip_newlines_from_detail(detail), expected);
225
226 let detail = "fn(\n Method,\n List(#(String, String)),\n a,\n Scheme,\n String,\n Option(Int),\n String,\n Option(String),\n) -> Request(a)";
227 let expected = "fn(Method, List(#(String, String)), a, Scheme, String, Option(Int), String, Option(String)) -> Request(a)";
228 assert_eq!(strip_newlines_from_detail(&detail), expected);
229 }
230}