Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Add builtin Pyrefly language server support (#44262)

Jia Chen953ac755299d
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index ba00539b41e..a84d168764e 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -13,7 +13,7 @@ pub use language::*;
use crate::{
json::JsonTaskProvider,
- python::{BasedPyrightLspAdapter, RuffLspAdapter},
+ python::{BasedPyrightLspAdapter, PyreflyLspAdapter, RuffLspAdapter},
};
mod bash;
@@ -74,6 +74,7 @@ pub fn init(languages: Arc<LanguageRegistry>, fs: Arc<dyn Fs>, node: NodeRuntime
let python_lsp_adapter = Arc::new(python::PyrightLspAdapter::new(node.clone()));
let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new(node.clone()));
let ruff_lsp_adapter = Arc::new(RuffLspAdapter::new(fs.clone()));
+ let pyrefly_lsp_adapter = Arc::new(PyreflyLspAdapter::new(fs.clone()));
let python_toolchain_provider = Arc::new(python::PythonToolchainProvider::new(fs.clone()));
let rust_context_provider = Arc::new(rust::RustContextProvider);
let rust_lsp_adapter = Arc::new(rust::RustLspAdapter);
@@ -169,6 +170,7 @@ pub fn init(languages: Arc<LanguageRegistry>, fs: Arc<dyn Fs>, node: NodeRuntime
ty_lsp_adapter,
py_lsp_adapter,
python_lsp_adapter,
+ pyrefly_lsp_adapter,
],
context: Some(python_context_provider),
toolchain: Some(python_toolchain_provider),
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 3c7b3c6de5d..2dcce71a38e 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -2722,6 +2722,306 @@ impl LspInstaller for RuffLspAdapter {
}
}
+pub(crate) struct PyreflyLspAdapter {
+ fs: Arc<dyn Fs>,
+}
+
+#[cfg(target_os = "macos")]
+impl PyreflyLspAdapter {
+ const GITHUB_ASSET_KIND: AssetKind = AssetKind::TarGz;
+ const ARCH_SERVER_NAME: &str = "macos";
+}
+
+#[cfg(target_os = "linux")]
+impl PyreflyLspAdapter {
+ const GITHUB_ASSET_KIND: AssetKind = AssetKind::TarGz;
+ const ARCH_SERVER_NAME: &str = "linux";
+}
+
+#[cfg(target_os = "windows")]
+impl PyreflyLspAdapter {
+ const GITHUB_ASSET_KIND: AssetKind = AssetKind::Zip;
+ const ARCH_SERVER_NAME: &str = "windows";
+}
+
+impl PyreflyLspAdapter {
+ const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("pyrefly");
+
+ pub(crate) fn new(fs: Arc<dyn Fs>) -> Self {
+ Self { fs }
+ }
+
+ fn build_asset_name() -> Result<(String, String)> {
+ let arch = match consts::ARCH {
+ "aarch64" => "arm64",
+ "x86" => "i686",
+ _ => consts::ARCH,
+ };
+ let os = Self::ARCH_SERVER_NAME;
+ let suffix = match consts::OS {
+ "windows" => "zip",
+ _ => "tar.gz",
+ };
+ let asset_name = format!("pyrefly-{os}-{arch}.{suffix}");
+ let asset_stem = format!("pyrefly-{os}-{arch}");
+ Ok((asset_stem, asset_name))
+ }
+}
+
+#[async_trait(?Send)]
+impl LspAdapter for PyreflyLspAdapter {
+ fn name(&self) -> LanguageServerName {
+ Self::SERVER_NAME
+ }
+
+ async fn process_completions(&self, _items: &mut [lsp::CompletionItem]) {}
+
+ async fn label_for_completion(
+ &self,
+ item: &lsp::CompletionItem,
+ language: &Arc<language::Language>,
+ ) -> Option<language::CodeLabel> {
+ let label = &item.label;
+ let label_len = label.len();
+ let grammar = language.grammar()?;
+ let highlight_id = match item.kind? {
+ lsp::CompletionItemKind::METHOD => grammar.highlight_id_for_name("function.method")?,
+ lsp::CompletionItemKind::FUNCTION => grammar.highlight_id_for_name("function")?,
+ lsp::CompletionItemKind::CLASS => grammar.highlight_id_for_name("type")?,
+ lsp::CompletionItemKind::CONSTANT => grammar.highlight_id_for_name("constant")?,
+ _ => return None,
+ };
+ Some(language::CodeLabel::filtered(
+ label.clone(),
+ label_len,
+ item.filter_text.as_deref(),
+ vec![(0..label.len(), highlight_id)],
+ ))
+ }
+
+ async fn label_for_symbol(
+ &self,
+ symbol: &Symbol,
+ language: &Arc<language::Language>,
+ ) -> Option<language::CodeLabel> {
+ label_for_python_symbol(symbol, language)
+ }
+
+ async fn workspace_configuration(
+ self: Arc<Self>,
+ adapter: &Arc<dyn LspAdapterDelegate>,
+ toolchain: Option<Toolchain>,
+ _: Option<Uri>,
+ cx: &mut AsyncApp,
+ ) -> Result<Value> {
+ let mut user_settings = cx
+ .update(move |cx| {
+ language_server_settings(adapter.as_ref(), &Self::SERVER_NAME, cx)
+ .and_then(|s| s.settings.clone())
+ })
+ .unwrap_or_default();
+
+ if let Some(toolchain) = toolchain
+ && let Ok(env) = serde_json::from_value::<PythonToolchainData>(toolchain.as_json)
+ {
+ if !user_settings.is_object() {
+ user_settings = Value::Object(serde_json::Map::default());
+ }
+ let object = user_settings.as_object_mut().unwrap();
+
+ if let Some(interpreter_path) = &env.environment.executable {
+ object.insert(
+ "pythonPath".to_owned(),
+ Value::String(interpreter_path.to_string_lossy().into_owned()),
+ );
+ }
+ }
+
+ Ok(user_settings)
+ }
+}
+
+impl LspInstaller for PyreflyLspAdapter {
+ type BinaryVersion = GitHubLspBinaryVersion;
+
+ async fn check_if_user_installed(
+ &self,
+ delegate: &Arc<dyn LspAdapterDelegate>,
+ toolchain: Option<Toolchain>,
+ _: &AsyncApp,
+ ) -> Option<LanguageServerBinary> {
+ let pyrefly_in_venv = if let Some(toolchain) = toolchain
+ && toolchain.language_name.as_ref() == "Python"
+ {
+ Path::new(toolchain.path.as_str())
+ .parent()
+ .map(|path| path.join("pyrefly"))
+ } else {
+ None
+ };
+
+ for path in pyrefly_in_venv.into_iter().chain(["pyrefly".into()]) {
+ if let Some(pyrefly_bin) = delegate.which(path.as_os_str()).await {
+ let env = delegate.shell_env().await;
+ return Some(LanguageServerBinary {
+ path: pyrefly_bin,
+ env: Some(env),
+ arguments: vec!["lsp".into()],
+ });
+ }
+ }
+
+ None
+ }
+
+ async fn fetch_latest_server_version(
+ &self,
+ delegate: &Arc<dyn LspAdapterDelegate>,
+ _: bool,
+ _: &mut AsyncApp,
+ ) -> Result<GitHubLspBinaryVersion> {
+ let release =
+ latest_github_release("facebook/pyrefly", true, false, delegate.http_client()).await?;
+ let (_, asset_name) = Self::build_asset_name()?;
+ let asset = release
+ .assets
+ .into_iter()
+ .find(|asset| asset.name == asset_name)
+ .with_context(|| format!("no asset found matching `{asset_name:?}`"))?;
+ Ok(GitHubLspBinaryVersion {
+ name: release.tag_name,
+ url: asset.browser_download_url,
+ digest: asset.digest,
+ })
+ }
+
+ fn fetch_server_binary(
+ &self,
+ latest_version: GitHubLspBinaryVersion,
+ container_dir: PathBuf,
+ delegate: &Arc<dyn LspAdapterDelegate>,
+ ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
+ let delegate = delegate.clone();
+
+ async move {
+ let GitHubLspBinaryVersion {
+ name,
+ url,
+ digest: expected_digest,
+ } = latest_version;
+ let destination_path = container_dir.join(format!("pyrefly-{name}"));
+
+ async_fs::create_dir_all(&destination_path).await?;
+
+ let server_path = match Self::GITHUB_ASSET_KIND {
+ AssetKind::TarGz | AssetKind::TarBz2 | AssetKind::Gz => {
+ destination_path.join("pyrefly")
+ }
+ AssetKind::Zip => destination_path.join("pyrefly.exe"),
+ };
+
+ let binary = LanguageServerBinary {
+ path: server_path.clone(),
+ env: None,
+ arguments: vec!["lsp".into()],
+ };
+
+ let metadata_path = destination_path.with_extension("metadata");
+ let metadata = GithubBinaryMetadata::read_from_file(&metadata_path)
+ .await
+ .ok();
+ if let Some(metadata) = metadata {
+ let validity_check = async || {
+ delegate
+ .try_exec(LanguageServerBinary {
+ path: server_path.clone(),
+ arguments: vec!["--version".into()],
+ env: None,
+ })
+ .await
+ .inspect_err(|err| {
+ log::warn!(
+ "Unable to run {server_path:?} asset, redownloading: {err:#}",
+ )
+ })
+ };
+ if let (Some(actual_digest), Some(expected_digest)) =
+ (&metadata.digest, &expected_digest)
+ {
+ if actual_digest == expected_digest {
+ if validity_check().await.is_ok() {
+ return Ok(binary);
+ }
+ } else {
+ log::info!(
+ "SHA-256 mismatch for {destination_path:?} asset, downloading new asset. Expected: {expected_digest}, Got: {actual_digest}"
+ );
+ }
+ } else if validity_check().await.is_ok() {
+ return Ok(binary);
+ }
+ }
+
+ download_server_binary(
+ &*delegate.http_client(),
+ &url,
+ expected_digest.as_deref(),
+ &destination_path,
+ Self::GITHUB_ASSET_KIND,
+ )
+ .await?;
+ make_file_executable(&server_path).await?;
+ remove_matching(&container_dir, |path| path != destination_path).await;
+ GithubBinaryMetadata::write_to_file(
+ &GithubBinaryMetadata {
+ metadata_version: 1,
+ digest: expected_digest,
+ },
+ &metadata_path,
+ )
+ .await?;
+
+ Ok(LanguageServerBinary {
+ path: server_path,
+ env: None,
+ arguments: vec!["lsp".into()],
+ })
+ }
+ }
+
+ async fn cached_server_binary(
+ &self,
+ container_dir: PathBuf,
+ _: &dyn LspAdapterDelegate,
+ ) -> Option<LanguageServerBinary> {
+ maybe!(async {
+ let mut last = None;
+ let mut entries = self.fs.read_dir(&container_dir).await?;
+ while let Some(entry) = entries.next().await {
+ let path = entry?;
+ if path.extension().is_some_and(|ext| ext == "metadata") {
+ continue;
+ }
+ last = Some(path);
+ }
+
+ let path = last.context("no cached binary")?;
+ let path = match Self::GITHUB_ASSET_KIND {
+ AssetKind::TarGz | AssetKind::TarBz2 | AssetKind::Gz => path.join("pyrefly"),
+ AssetKind::Zip => path.join("pyrefly.exe"),
+ };
+
+ anyhow::Ok(LanguageServerBinary {
+ path,
+ env: None,
+ arguments: vec!["lsp".into()],
+ })
+ })
+ .await
+ .log_err()
+ }
+}
+
#[cfg(test)]
mod tests {
use gpui::{AppContext as _, BorrowAppContext, Context, TestAppContext};
diff --git a/docs/src/languages/python.md b/docs/src/languages/python.md
index 557f420750b..14e5e1d47d4 100644
--- a/docs/src/languages/python.md
+++ b/docs/src/languages/python.md
@@ -12,6 +12,7 @@ Python support is available natively in Zed.
- [DetachHead/basedpyright](https://github.com/DetachHead/basedpyright)
- [astral-sh/ruff](https://github.com/astral-sh/ruff)
- [astral-sh/ty](https://github.com/astral-sh/ty)
+ - [facebook/pyrefly](https://github.com/facebook/pyrefly)
- [microsoft/pyright](https://github.com/microsoft/pyright)
- [python-lsp/python-lsp-server](https://github.com/python-lsp/python-lsp-server) (PyLSP)
- Debug Adapter: [debugpy](https://github.com/microsoft/debugpy)
@@ -76,7 +77,8 @@ Zed provides several Python language servers out of the box. By default, [basedp
Other built-in language servers are:
-- [ty](https://docs.astral.sh/ty/)&mdash;Up-and-coming language server from Astral, built for speed.
+- [Ty](https://docs.astral.sh/ty/)&mdash;Up-and-coming language server from Astral, built for speed.
+- [Pyrefly](https://pyrefly.org)&mdash;Language server and type checker using inference for accurate navigation and type safety.
- [Pyright](https://github.com/microsoft/pyright)&mdash;The basis for basedpyright.
- [PyLSP](https://github.com/python-lsp/python-lsp-server)&mdash;A plugin-based language server that integrates with tools like `pycodestyle`, `autopep8`, and `yapf`.
@@ -170,6 +172,41 @@ Here's an example `pyrightconfig.json` file that configures basedpyright to use
See [Python Language Server Configuration](https://github.com/python-lsp/python-lsp-server/blob/develop/CONFIGURATION.md) for more.
+### Pyrefly
+
+[Pyrefly](https://pyrefly.org) is a modern Python type checker and language server from Meta with powerful IDE features.
+
+#### Showing Type Errors
+
+By default, Pyrefly only displays type errors when a configuration file is present in your project. To see type errors in Zed:
+
+**Create a configuration file** (recommended): Add a `pyrefly.toml` or configure `[tool.pyrefly]` in your `pyproject.toml` at the root of your project. This is the standard way to use Pyrefly and allows you to customize its behavior.
+
+Example minimal `pyrefly.toml`:
+
+```toml
+# Check all Python files in your project
+project-includes = ["."]
+```
+
+For comprehensive configuration options, see the [Pyrefly configuration documentation](https://pyrefly.org/docs/configuration).
+
+Alternatively, add to the `lsp` section of your zed config file to tell Pyrefly to always display type errors:
+
+```json
+"lsp": {
+ "pyrefly": {
+ "initialization_options": {
+ "python": {
+ "pyrefly": {
+ "displayTypeErrors": "force-on"
+ }
+ }
+ }
+ }
+}
+```
+
## Virtual Environments
[Virtual environments](https://docs.python.org/3/library/venv.html) are a useful tool for fixing a Python version and set of dependencies for a specific project, in a way that's isolated from other projects on the same machine. Zed has built-in support for discovering, configuring, and activating virtual environments, based on the language-agnostic concept of a [toolchain](../toolchains.md).