1use std::fs;
2use zed::lsp::CompletionKind;
3use zed::{CodeLabel, CodeLabelSpan, LanguageServerId};
4use zed_extension_api::{self as zed, Result};
5
6struct LuaExtension {
7 cached_binary_path: Option<String>,
8}
9
10impl LuaExtension {
11 fn language_server_binary_path(
12 &mut self,
13 language_server_id: &LanguageServerId,
14 worktree: &zed::Worktree,
15 ) -> Result<String> {
16 if let Some(path) = worktree.which("lua-language-server") {
17 return Ok(path);
18 }
19
20 if let Some(path) = &self.cached_binary_path {
21 if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
22 return Ok(path.clone());
23 }
24 }
25
26 zed::set_language_server_installation_status(
27 language_server_id,
28 &zed::LanguageServerInstallationStatus::CheckingForUpdate,
29 );
30 let release = zed::latest_github_release(
31 "LuaLS/lua-language-server",
32 zed::GithubReleaseOptions {
33 require_assets: true,
34 pre_release: false,
35 },
36 )?;
37
38 let (platform, arch) = zed::current_platform();
39 let asset_name = format!(
40 "lua-language-server-{version}-{os}-{arch}.{extension}",
41 version = release.version,
42 os = match platform {
43 zed::Os::Mac => "darwin",
44 zed::Os::Linux => "linux",
45 zed::Os::Windows => "win32",
46 },
47 arch = match arch {
48 zed::Architecture::Aarch64 => "arm64",
49 zed::Architecture::X8664 => "x64",
50 zed::Architecture::X86 => return Err("unsupported platform x86".into()),
51 },
52 extension = match platform {
53 zed::Os::Mac | zed::Os::Linux => "tar.gz",
54 zed::Os::Windows => "zip",
55 },
56 );
57
58 let asset = release
59 .assets
60 .iter()
61 .find(|asset| asset.name == asset_name)
62 .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
63
64 let version_dir = format!("lua-language-server-{}", release.version);
65 let binary_path = format!(
66 "{version_dir}/bin/lua-language-server{extension}",
67 extension = match platform {
68 zed::Os::Mac | zed::Os::Linux => "",
69 zed::Os::Windows => ".exe",
70 },
71 );
72
73 if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
74 zed::set_language_server_installation_status(
75 language_server_id,
76 &zed::LanguageServerInstallationStatus::Downloading,
77 );
78
79 zed::download_file(
80 &asset.download_url,
81 &version_dir,
82 match platform {
83 zed::Os::Mac | zed::Os::Linux => zed::DownloadedFileType::GzipTar,
84 zed::Os::Windows => zed::DownloadedFileType::Zip,
85 },
86 )
87 .map_err(|e| format!("failed to download file: {e}"))?;
88
89 let entries =
90 fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
91 for entry in entries {
92 let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
93 if entry.file_name().to_str() != Some(&version_dir) {
94 fs::remove_dir_all(entry.path()).ok();
95 }
96 }
97 }
98
99 self.cached_binary_path = Some(binary_path.clone());
100 Ok(binary_path)
101 }
102}
103
104impl zed::Extension for LuaExtension {
105 fn new() -> Self {
106 Self {
107 cached_binary_path: None,
108 }
109 }
110
111 fn language_server_command(
112 &mut self,
113 language_server_id: &LanguageServerId,
114 worktree: &zed::Worktree,
115 ) -> Result<zed::Command> {
116 Ok(zed::Command {
117 command: self.language_server_binary_path(language_server_id, worktree)?,
118 args: Default::default(),
119 env: Default::default(),
120 })
121 }
122
123 fn label_for_completion(
124 &self,
125 _language_server_id: &LanguageServerId,
126 completion: zed::lsp::Completion,
127 ) -> Option<CodeLabel> {
128 match completion.kind? {
129 CompletionKind::Method | CompletionKind::Function => {
130 let name_len = completion.label.find('(').unwrap_or(completion.label.len());
131 Some(CodeLabel {
132 spans: vec![CodeLabelSpan::code_range(0..completion.label.len())],
133 filter_range: (0..name_len).into(),
134 code: completion.label,
135 })
136 }
137 CompletionKind::Field => Some(CodeLabel {
138 spans: vec![CodeLabelSpan::literal(
139 completion.label.clone(),
140 Some("property".into()),
141 )],
142 filter_range: (0..completion.label.len()).into(),
143 code: Default::default(),
144 }),
145 _ => None,
146 }
147 }
148
149 fn label_for_symbol(
150 &self,
151 _language_server_id: &LanguageServerId,
152 symbol: zed::lsp::Symbol,
153 ) -> Option<CodeLabel> {
154 let prefix = "let a = ";
155 let suffix = match symbol.kind {
156 zed::lsp::SymbolKind::Method => "()",
157 _ => "",
158 };
159 let code = format!("{prefix}{}{suffix}", symbol.name);
160 Some(CodeLabel {
161 spans: vec![CodeLabelSpan::code_range(
162 prefix.len()..code.len() - suffix.len(),
163 )],
164 filter_range: (0..symbol.name.len()).into(),
165 code,
166 })
167 }
168}
169
170zed::register_extension!(LuaExtension);