1use std::fs;
  2use zed::LanguageServerId;
  3use zed_extension_api::{self as zed, Result};
  4
  5struct ZigExtension {
  6    cached_binary_path: Option<String>,
  7}
  8
  9#[derive(Clone)]
 10struct ZlsBinary {
 11    path: String,
 12    environment: Option<Vec<(String, String)>>,
 13}
 14
 15impl ZigExtension {
 16    fn language_server_binary(
 17        &mut self,
 18        language_server_id: &LanguageServerId,
 19        worktree: &zed::Worktree,
 20    ) -> Result<ZlsBinary> {
 21        if let Some(path) = worktree.which("zls") {
 22            let environment = worktree.shell_env();
 23            return Ok(ZlsBinary {
 24                path,
 25                environment: Some(environment),
 26            });
 27        }
 28
 29        if let Some(path) = &self.cached_binary_path {
 30            if fs::metadata(&path).map_or(false, |stat| stat.is_file()) {
 31                return Ok(ZlsBinary {
 32                    path: path.clone(),
 33                    environment: None,
 34                });
 35            }
 36        }
 37
 38        zed::set_language_server_installation_status(
 39            &language_server_id,
 40            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
 41        );
 42        // We're pinning ZLS to a release that has `.tar.gz` assets, since the latest release does not have
 43        // them, at time of writing.
 44        //
 45        // ZLS tracking issue: https://github.com/zigtools/zls/issues/1879
 46        let release = zed::github_release_by_tag_name("zigtools/zls", "0.11.0")?;
 47
 48        let (platform, arch) = zed::current_platform();
 49        let asset_name = format!(
 50            "zls-{arch}-{os}.{extension}",
 51            arch = match arch {
 52                zed::Architecture::Aarch64 => "aarch64",
 53                zed::Architecture::X86 => "x86",
 54                zed::Architecture::X8664 => "x86_64",
 55            },
 56            os = match platform {
 57                zed::Os::Mac => "macos",
 58                zed::Os::Linux => "linux",
 59                zed::Os::Windows => "windows",
 60            },
 61            extension = match platform {
 62                zed::Os::Mac | zed::Os::Linux => "tar.gz",
 63                zed::Os::Windows => "zip",
 64            }
 65        );
 66
 67        let asset = release
 68            .assets
 69            .iter()
 70            .find(|asset| asset.name == asset_name)
 71            .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
 72
 73        let version_dir = format!("zls-{}", release.version);
 74        let binary_path = format!("{version_dir}/bin/zls");
 75
 76        if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
 77            zed::set_language_server_installation_status(
 78                &language_server_id,
 79                &zed::LanguageServerInstallationStatus::Downloading,
 80            );
 81
 82            zed::download_file(
 83                &asset.download_url,
 84                &version_dir,
 85                match platform {
 86                    zed::Os::Mac | zed::Os::Linux => zed::DownloadedFileType::GzipTar,
 87                    zed::Os::Windows => zed::DownloadedFileType::Zip,
 88                },
 89            )
 90            .map_err(|e| format!("failed to download file: {e}"))?;
 91
 92            zed::make_file_executable(&binary_path)?;
 93
 94            let entries =
 95                fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
 96            for entry in entries {
 97                let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
 98                if entry.file_name().to_str() != Some(&version_dir) {
 99                    fs::remove_dir_all(&entry.path()).ok();
100                }
101            }
102        }
103
104        self.cached_binary_path = Some(binary_path.clone());
105        Ok(ZlsBinary {
106            path: binary_path,
107            environment: None,
108        })
109    }
110}
111
112impl zed::Extension for ZigExtension {
113    fn new() -> Self {
114        Self {
115            cached_binary_path: None,
116        }
117    }
118
119    fn language_server_command(
120        &mut self,
121        language_server_id: &LanguageServerId,
122        worktree: &zed::Worktree,
123    ) -> Result<zed::Command> {
124        let zls_binary = self.language_server_binary(language_server_id, worktree)?;
125        Ok(zed::Command {
126            command: zls_binary.path,
127            args: vec![],
128            env: zls_binary.environment.unwrap_or_default(),
129        })
130    }
131}
132
133zed::register_extension!(ZigExtension);