Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

elixir: Extract to zed-extensions/elixir repository (#26167)

Browse source 
This PR extracts the Elixir extension to the
[zed-extensions/elixir](https://github.com/zed-extensions/elixir)
repository.

Release Notes:

- N/A
This commit is contained in:
Marshall Bowers 2025-03-05 17:50:35 -05:00 • committed by GitHub
parent 5daadc0d30
commit 4db9ab15a7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
26 changed files with 1 additions and 1231 deletions
Download patch file Download diff file Expand all files Collapse all files

18
Cargo.lock generated
View file

@ -16996,13 +16996,6 @@ dependencies = [
"serde",
]
[[package]]
name = "zed_elixir"
version = "0.1.4"
dependencies = [
"zed_extension_api 0.2.0",
]
[[package]]
name = "zed_emmet"
version = "0.0.3"
@ -17028,17 +17021,6 @@ dependencies = [
"wit-bindgen",
]
[[package]]
name = "zed_extension_api"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fd16b8b30a9dc920fc1678ff852f696b5bdf5b5843bc745a128be0aac29859e"
dependencies = [
"serde",
"serde_json",
"wit-bindgen",
]
[[package]]
name = "zed_extension_api"
version = "0.3.0"

1
Cargo.toml
View file

@ -168,7 +168,6 @@ members = [
# Extensions
#
"extensions/elixir",
"extensions/emmet",
"extensions/erlang",
"extensions/glsl",

2
docs/src/languages/elixir.md
View file

@ -1,6 +1,6 @@
# Elixir
Elixir support is available through the [Elixir extension](https://github.com/zed-industries/zed/tree/main/extensions/elixir).
Elixir support is available through the [Elixir extension](https://github.com/zed-extensions/elixir).
- Tree-sitter:
- [elixir-lang/tree-sitter-elixir](https://github.com/elixir-lang/tree-sitter-elixir)

16
extensions/elixir/Cargo.toml
View file

@ -1,16 +0,0 @@
[package]
name = "zed_elixir"
version = "0.1.4"
edition.workspace = true
publish.workspace = true
license = "Apache-2.0"
[lints]
workspace = true
[lib]
path = "src/elixir.rs"
crate-type = ["cdylib"]
[dependencies]
zed_extension_api = "0.2.0"

1
extensions/elixir/LICENSE-APACHE
View file

@ -1 +0,0 @@
../../LICENSE-APACHE

27
extensions/elixir/extension.toml
View file

@ -1,27 +0,0 @@
id = "elixir"
name = "Elixir"
description = "Elixir support."
version = "0.1.4"
schema_version = 1
authors = ["Marshall Bowers <elliott.codes@gmail.com>"]
repository = "https://github.com/zed-industries/zed"
[language_servers.elixir-ls]
name = "ElixirLS"
languages = ["Elixir", "HEEX"]
[language_servers.next-ls]
name = "Next LS"
languages = ["Elixir", "HEEX"]
[language_servers.lexical]
name = "Lexical"
languages = ["Elixir", "HEEX"]
[grammars.elixir]
repository = "https://github.com/elixir-lang/tree-sitter-elixir"
commit = "a2861e88a730287a60c11ea9299c033c7d076e30"
[grammars.heex]
repository = "https://github.com/phoenixframework/tree-sitter-heex"
commit = "2e1348c3cf2c9323e87c2744796cf3f3868aa82a"

5
extensions/elixir/languages/elixir/brackets.scm
View file

@ -1,5 +0,0 @@
("(" @open ")" @close)
("[" @open "]" @close)
("{" @open "}" @close)
("\"" @open "\"" @close)
("do" @open "end" @close)

18
extensions/elixir/languages/elixir/config.toml
View file

@ -1,18 +0,0 @@
name = "Elixir"
grammar = "elixir"
path_suffixes = ["ex", "exs"]
line_comments = ["# "]
autoclose_before = ";:.,=}])>"
brackets = [
{ start = "{", end = "}", close = true, newline = true },
{ start = "[", end = "]", close = true, newline = true },
{ start = "(", end = ")", close = true, newline = true },
{ start = "\"", end = "\"", close = true, newline = false, not_in = ["string", "comment"] },
{ start = "'", end = "'", close = true, newline = false, not_in = ["string", "comment"] },
]
tab_size = 2
scope_opt_in_language_servers = ["tailwindcss-language-server"]
[overrides.string]
word_characters = ["-"]
opt_into_language_servers = ["tailwindcss-language-server"]

27
extensions/elixir/languages/elixir/embedding.scm
View file

@ -1,27 +0,0 @@
(
(unary_operator
operator: "@"
operand: (call
target: (identifier) @unary
(#match? @unary "^(doc)$"))
) @context
.
(call
target: (identifier) @name
(arguments
[
(identifier) @name
(call
target: (identifier) @name)
(binary_operator
left: (call
target: (identifier) @name)
operator: "when")
])
(#match? @name "^(def|defp|defdelegate|defguard|defguardp|defmacro|defmacrop|defn|defnp)$")) @item
)
(call
target: (identifier) @name
(arguments (alias) @name)
(#match? @name "^(defmodule|defprotocol)$")) @item

155
extensions/elixir/languages/elixir/highlights.scm
View file

@ -1,155 +0,0 @@
["when" "and" "or" "not" "in" "not in" "fn" "do" "end" "catch" "rescue" "after" "else"] @keyword
(unary_operator
operator: "&"
operand: (integer) @operator)
(operator_identifier) @operator
(unary_operator
operator: _ @operator)
(binary_operator
operator: _ @operator)
(dot
operator: _ @operator)
(stab_clause
operator: _ @operator)
[
(boolean)
(nil)
] @constant
[
(integer)
(float)
] @number
(alias) @type
(call
target: (dot
left: (atom) @type))
(char) @constant
(escape_sequence) @string.escape
[
(atom)
(quoted_atom)
(keyword)
(quoted_keyword)
] @string.special.symbol
[
(string)
(charlist)
] @string
(sigil
(sigil_name) @__name__
quoted_start: _ @string
quoted_end: _ @string
(#match? @__name__ "^[sS]$")) @string
(sigil
(sigil_name) @__name__
quoted_start: _ @string.regex
quoted_end: _ @string.regex
(#match? @__name__ "^[rR]$")) @string.regex
(sigil
(sigil_name) @__name__
quoted_start: _ @string.special
quoted_end: _ @string.special) @string.special
(identifier) @variable
(
(identifier) @comment.unused
(#match? @comment.unused "^_")
)
(call
target: [
(identifier) @function
(dot
right: (identifier) @function)
])
(call
target: (identifier) @keyword
(arguments
[
(identifier) @function
(binary_operator
left: (identifier) @function
operator: "when")
(binary_operator
operator: "|>"
right: (identifier))
])
(#match? @keyword "^(def|defdelegate|defguard|defguardp|defmacro|defmacrop|defn|defnp|defp)$"))
(binary_operator
operator: "|>"
right: (identifier) @function)
(call
target: (identifier) @keyword
(#match? @keyword "^(def|defdelegate|defexception|defguard|defguardp|defimpl|defmacro|defmacrop|defmodule|defn|defnp|defoverridable|defp|defprotocol|defstruct)$"))
(call
target: (identifier) @keyword
(#match? @keyword "^(alias|case|cond|else|for|if|import|quote|raise|receive|require|reraise|super|throw|try|unless|unquote|unquote_splicing|use|with)$"))
(
(identifier) @constant.builtin
(#match? @constant.builtin "^(__MODULE__|__DIR__|__ENV__|__CALLER__|__STACKTRACE__)$")
)
(unary_operator
operator: "@" @comment.doc
operand: (call
target: (identifier) @__attribute__ @comment.doc
(arguments
[
(string)
(charlist)
(sigil)
(boolean)
] @comment.doc))
(#match? @__attribute__ "^(moduledoc|typedoc|doc)$"))
(comment) @comment
[
"%"
] @punctuation
[
","
";"
] @punctuation.delimiter
[
"("
")"
"["
"]"
"{"
"}"
"<<"
">>"
] @punctuation.bracket
(interpolation "#{" @punctuation.special "}" @punctuation.special) @embedded
((sigil
(sigil_name) @_sigil_name
(quoted_content) @embedded)
(#eq? @_sigil_name "H"))

6
extensions/elixir/languages/elixir/indents.scm
View file

@ -1,6 +0,0 @@
(call) @indent
(_ "[" "]" @end) @indent
(_ "{" "}" @end) @indent
(_ "(" ")" @end) @indent
(_ "do" "end" @end) @indent

7
extensions/elixir/languages/elixir/injections.scm
View file

@ -1,7 +0,0 @@
; Phoenix HTML template
((sigil
(sigil_name) @_sigil_name
(quoted_content) @injection.content)
(#eq? @_sigil_name "H")
(#set! injection.language "heex"))

56
extensions/elixir/languages/elixir/outline.scm
View file

@ -1,56 +0,0 @@
(call
target: (identifier) @context
(arguments (alias) @name)
(#match? @context "^(defmodule|defprotocol)$")) @item
(call
target: (identifier) @context
(arguments (_) @name)?
(#match? @context "^(setup|setup_all)$")) @item
(call
target: (identifier) @context
(arguments (string) @name)
(#match? @context "^(describe|test)$")) @item
(unary_operator
operator: "@" @name
operand: (call
target: (identifier) @context
(arguments
[
(binary_operator
left: (identifier) @name)
(binary_operator
left: (call
target: (identifier) @name
(arguments
"(" @context.extra
_* @context.extra
")" @context.extra)))
]
)
)
(#match? @context "^(callback|type|typep)$")) @item
(call
target: (identifier) @context
(arguments
[
(identifier) @name
(call
target: (identifier) @name
(arguments
"(" @context.extra
_* @context.extra
")" @context.extra))
(binary_operator
left: (call
target: (identifier) @name
(arguments
"(" @context.extra
_* @context.extra
")" @context.extra))
operator: "when")
])
(#match? @context "^(def|defp|defdelegate|defguard|defguardp|defmacro|defmacrop|defn|defnp)$")) @item

2
extensions/elixir/languages/elixir/overrides.scm
View file

@ -1,2 +0,0 @@
(comment) @comment.inclusive
[(string) (charlist)] @string

20
extensions/elixir/languages/elixir/runnables.scm
View file

@ -1,20 +0,0 @@
; Macros `describe`, `test` and `property`.
; This matches the ExUnit test style.
(
(call
target: (identifier) @run (#any-of? @run "describe" "test" "property")
) @_elixir-test
(#set! tag elixir-test)
)
; Modules containing at least one `describe`, `test` and `property`.
; This matches the ExUnit test style.
(
(call
target: (identifier) @run (#eq? @run "defmodule")
(do_block
(call target: (identifier) @_keyword (#any-of? @_keyword "describe" "test" "property"))
)
) @_elixir-module-test
(#set! tag elixir-module-test)
)

30
extensions/elixir/languages/elixir/tasks.json
View file

@ -1,30 +0,0 @@
// Taken from https://gist.github.com/josevalim/2e4f60a14ccd52728e3256571259d493#gistcomment-4995881
[
{
"label": "mix test",
"command": "mix",
"args": ["test"]
},
{
"label": "mix test --failed",
"command": "mix",
"args": ["test", "--failed"]
},
{
"label": "mix test $ZED_RELATIVE_FILE",
"command": "mix",
"args": ["test", "$ZED_RELATIVE_FILE"],
"tags": ["elixir-module-test"]
},
{
"label": "mix test $ZED_RELATIVE_FILE:$ZED_ROW",
"command": "mix",
"args": ["test", "$ZED_RELATIVE_FILE:$ZED_ROW"],
"tags": ["elixir-test"]
},
{
"label": "Elixir: break line",
"command": "iex",
"args": ["-S", "mix", "test", "-b", "$ZED_RELATIVE_FILE:$ZED_ROW"]
}
]

46
extensions/elixir/languages/elixir/textobjects.scm
View file

@ -1,46 +0,0 @@
(call
target: ((identifier) @_identifier
(#any-of? @_identifier "defmodule" "defprotocol" "defimpl"))
(do_block
"do"
(_)* @class.inside
"end")) @class.around
(anonymous_function
(stab_clause
right: (body) @function.inside)) @function.around
(call
target: ((identifier) @_identifier
(#any-of? @_identifier "def" "defmacro" "defmacrop" "defn" "defnp" "defp"))
(do_block
"do"
(_)* @function.inside
"end")) @function.around
(call
target: ((identifier) @_identifier
(#any-of? @_identifier "def" "defmacro" "defmacrop" "defn" "defnp" "defp"))
(arguments
(_)
(keywords
(pair
value: (_) @function.inside)))) @function.around
(call
target: ((identifier) @_identifier
(#any-of? @_identifier "defdelegate" "defguard" "defguardp"))) @function.around
(comment) @comment.around
(unary_operator
operator: "@"
operand: (call
target: ((identifier) @_identifier
(#any-of? @_identifier "moduledoc" "typedoc" "shortdoc" "doc"))
(arguments
[
(keywords) @comment.inside
(string
(quoted_content) @comment.inside)
]))) @comment.around

13
extensions/elixir/languages/heex/config.toml
View file

@ -1,13 +0,0 @@
name = "HEEX"
grammar = "heex"
path_suffixes = ["heex"]
autoclose_before = ">})"
brackets = [
{ start = "<", end = ">", close = true, newline = true },
]
block_comment = ["<%!-- ", " --%>"]
scope_opt_in_language_servers = ["tailwindcss-language-server"]
[overrides.string]
word_characters = ["-"]
opt_into_language_servers = ["tailwindcss-language-server"]

57
extensions/elixir/languages/heex/highlights.scm
View file

@ -1,57 +0,0 @@
; HEEx delimiters
[
"/>"
"<!"
"<"
"</"
"</:"
"<:"
">"
"{"
"}"
] @punctuation.bracket
[
"<%!--"
"<%"
"<%#"
"<%%="
"<%="
"%>"
"--%>"
"-->"
"<!--"
] @keyword
; HEEx operators are highlighted as such
"=" @operator
; HEEx inherits the DOCTYPE tag from HTML
(doctype) @tag.doctype
(comment) @comment
; HEEx tags and slots are highlighted as HTML
[
(tag_name)
(slot_name)
] @tag
; HEEx attributes are highlighted as HTML attributes
(attribute_name) @attribute
; HEEx special attributes are highlighted as keywords
(special_attribute_name) @keyword
[
(attribute_value)
(quoted_attribute_value)
] @string
; HEEx components are highlighted as Elixir modules and functions
(component_name
[
(module) @module
(function) @function
"." @punctuation.delimiter
])

13
extensions/elixir/languages/heex/injections.scm
View file

@ -1,13 +0,0 @@
(
(directive
[
(partial_expression_value)
(expression_value)
(ending_expression_value)
] @injection.content)
(#set! injection.language "elixir")
(#set! injection.combined)
)
((expression (expression_value) @injection.content)
(#set! injection.language "elixir"))

4
extensions/elixir/languages/heex/overrides.scm
View file

@ -1,4 +0,0 @@
[
(attribute_value)
(quoted_attribute_value)
] @string

123
extensions/elixir/src/elixir.rs
View file

@ -1,123 +0,0 @@
mod language_servers;
use zed::lsp::{Completion, Symbol};
use zed::{serde_json, CodeLabel, LanguageServerId};
use zed_extension_api::{self as zed, Result};
use crate::language_servers::{ElixirLs, Lexical, NextLs};
struct ElixirExtension {
elixir_ls: Option<ElixirLs>,
next_ls: Option<NextLs>,
lexical: Option<Lexical>,
}
impl zed::Extension for ElixirExtension {
fn new() -> Self {
Self {
elixir_ls: None,
next_ls: None,
lexical: None,
}
}
fn language_server_command(
&mut self,
language_server_id: &LanguageServerId,
worktree: &zed::Worktree,
) -> Result<zed::Command> {
match language_server_id.as_ref() {
ElixirLs::LANGUAGE_SERVER_ID => {
let elixir_ls = self.elixir_ls.get_or_insert_with(ElixirLs::new);
Ok(zed::Command {
command: elixir_ls.language_server_binary_path(language_server_id, worktree)?,
args: vec![],
env: Default::default(),
})
}
NextLs::LANGUAGE_SERVER_ID => {
let next_ls = self.next_ls.get_or_insert_with(NextLs::new);
Ok(zed::Command {
command: next_ls.language_server_binary_path(language_server_id, worktree)?,
args: vec!["--stdio".to_string()],
env: Default::default(),
})
}
Lexical::LANGUAGE_SERVER_ID => {
let lexical = self.lexical.get_or_insert_with(Lexical::new);
let lexical_binary =
lexical.language_server_binary(language_server_id, worktree)?;
Ok(zed::Command {
command: lexical_binary.path,
args: lexical_binary.args.unwrap_or_default(),
env: Default::default(),
})
}
language_server_id => Err(format!("unknown language server: {language_server_id}")),
}
}
fn label_for_completion(
&self,
language_server_id: &LanguageServerId,
completion: Completion,
) -> Option<CodeLabel> {
match language_server_id.as_ref() {
ElixirLs::LANGUAGE_SERVER_ID => {
self.elixir_ls.as_ref()?.label_for_completion(completion)
}
NextLs::LANGUAGE_SERVER_ID => self.next_ls.as_ref()?.label_for_completion(completion),
Lexical::LANGUAGE_SERVER_ID => self.lexical.as_ref()?.label_for_completion(completion),
_ => None,
}
}
fn label_for_symbol(
&self,
language_server_id: &LanguageServerId,
symbol: Symbol,
) -> Option<CodeLabel> {
match language_server_id.as_ref() {
ElixirLs::LANGUAGE_SERVER_ID => self.elixir_ls.as_ref()?.label_for_symbol(symbol),
NextLs::LANGUAGE_SERVER_ID => self.next_ls.as_ref()?.label_for_symbol(symbol),
Lexical::LANGUAGE_SERVER_ID => self.lexical.as_ref()?.label_for_symbol(symbol),
_ => None,
}
}
fn language_server_initialization_options(
&mut self,
language_server_id: &LanguageServerId,
_worktree: &zed::Worktree,
) -> Result<Option<serde_json::Value>> {
match language_server_id.as_ref() {
NextLs::LANGUAGE_SERVER_ID => Ok(Some(serde_json::json!({
"experimental": {
"completions": {
"enable": true
}
}
}))),
_ => Ok(None),
}
}
fn language_server_workspace_configuration(
&mut self,
language_server_id: &LanguageServerId,
worktree: &zed::Worktree,
) -> Result<Option<serde_json::Value>> {
if language_server_id.as_ref() == ElixirLs::LANGUAGE_SERVER_ID {
if let Some(elixir_ls) = self.elixir_ls.as_mut() {
return elixir_ls.language_server_workspace_configuration(worktree);
}
}
Ok(None)
}
}
zed::register_extension!(ElixirExtension);

7
extensions/elixir/src/language_servers.rs
View file

@ -1,7 +0,0 @@
mod elixir_ls;
mod lexical;
mod next_ls;
pub use elixir_ls::*;
pub use lexical::*;
pub use next_ls::*;

231
extensions/elixir/src/language_servers/elixir_ls.rs
View file

@ -1,231 +0,0 @@
use std::fs;
use zed::lsp::{Completion, CompletionKind, Symbol, SymbolKind};
use zed::settings::LspSettings;
use zed::{serde_json, CodeLabel, CodeLabelSpan, LanguageServerId};
use zed_extension_api::{self as zed, Result};
pub struct ElixirLs {
cached_binary_path: Option<String>,
}
impl ElixirLs {
pub const LANGUAGE_SERVER_ID: &'static str = "elixir-ls";
pub fn new() -> Self {
Self {
cached_binary_path: None,
}
}
pub fn language_server_binary_path(
&mut self,
language_server_id: &LanguageServerId,
worktree: &zed::Worktree,
) -> Result<String> {
if let Some(path) = worktree.which("elixir-ls") {
return Ok(path);
}
if let Some(path) = &self.cached_binary_path {
if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
return Ok(path.clone());
}
}
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::CheckingForUpdate,
);
let release = zed::latest_github_release(
"elixir-lsp/elixir-ls",
zed::GithubReleaseOptions {
require_assets: true,
pre_release: false,
},
)?;
let asset_name = format!("elixir-ls-{version}.zip", version = release.version,);
let asset = release
.assets
.iter()
.find(|asset| asset.name == asset_name)
.ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
let (platform, _arch) = zed::current_platform();
let version_dir = format!("elixir-ls-{}", release.version);
let extension = match platform {
zed::Os::Mac | zed::Os::Linux => "sh",
zed::Os::Windows => "bat",
};
let binary_path = format!("{version_dir}/language_server.{extension}");
if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::Downloading,
);
zed::download_file(
&asset.download_url,
&version_dir,
zed::DownloadedFileType::Zip,
)
.map_err(|e| format!("failed to download file: {e}"))?;
zed::make_file_executable(&binary_path)?;
zed::make_file_executable(&format!("{version_dir}/launch.{extension}"))?;
zed::make_file_executable(&format!("{version_dir}/debug_adapter.{extension}"))?;
let entries =
fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
for entry in entries {
let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
if entry.file_name().to_str() != Some(&version_dir) {
fs::remove_dir_all(entry.path()).ok();
}
}
}
self.cached_binary_path = Some(binary_path.clone());
Ok(binary_path)
}
pub fn language_server_workspace_configuration(
&mut self,
worktree: &zed::Worktree,
) -> Result<Option<serde_json::Value>> {
let settings = LspSettings::for_worktree("elixir-ls", worktree)
.ok()
.and_then(|lsp_settings| lsp_settings.settings.clone())
.unwrap_or_default();
Ok(Some(serde_json::json!({
"elixirLS": settings
})))
}
pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
let name = &completion.label;
let detail = completion
.detail
.filter(|detail| detail != "alias")
.map(|detail| format!(": {detail}"))
.unwrap_or("".to_string());
let detail_span = CodeLabelSpan::literal(detail, Some("comment.unused".to_string()));
match completion.kind? {
CompletionKind::Module | CompletionKind::Class | CompletionKind::Struct => {
let defmodule = "defmodule ";
let alias = completion
.label_details
.and_then(|details| details.description)
.filter(|description| description.starts_with("alias"))
.map(|description| format!(" ({description})"))
.unwrap_or("".to_string());
let code = format!("{defmodule}{name}{alias}");
let name_start = defmodule.len();
let name_end = name_start + name.len();
Some(CodeLabel {
code,
spans: vec![
CodeLabelSpan::code_range(name_start..name_end),
detail_span,
CodeLabelSpan::code_range(name_end..(name_end + alias.len())),
],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Interface => Some(CodeLabel {
code: name.to_string(),
spans: vec![CodeLabelSpan::code_range(0..name.len()), detail_span],
filter_range: (0..name.len()).into(),
}),
CompletionKind::Field => Some(CodeLabel {
code: name.to_string(),
spans: vec![
CodeLabelSpan::literal(name, Some("function".to_string())),
detail_span,
],
filter_range: (0..name.len()).into(),
}),
CompletionKind::Function | CompletionKind::Constant => {
let detail = completion
.label_details
.clone()
.and_then(|details| details.detail)
.unwrap_or("".to_string());
let description = completion
.label_details
.clone()
.and_then(|details| details.description)
.map(|description| format!(" ({description})"))
.unwrap_or("".to_string());
let def = "def ";
let code = format!("{def}{name}{detail}{description}");
let name_start = def.len();
let name_end = name_start + name.len();
let detail_end = name_end + detail.len();
let description_end = detail_end + description.len();
Some(CodeLabel {
code,
spans: vec![
CodeLabelSpan::code_range(name_start..name_end),
CodeLabelSpan::code_range(name_end..detail_end),
CodeLabelSpan::code_range(detail_end..description_end),
],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Operator => {
let def_a = "def a ";
let code = format!("{def_a}{name} b");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(
def_a.len()..def_a.len() + name.len(),
)],
filter_range: (0..name.len()).into(),
})
}
_ => None,
}
}
pub fn label_for_symbol(&self, symbol: Symbol) -> Option<CodeLabel> {
let name = &symbol.name;
let (code, filter_range, display_range) = match symbol.kind {
SymbolKind::Module | SymbolKind::Class | SymbolKind::Interface | SymbolKind::Struct => {
let defmodule = "defmodule ";
let code = format!("{defmodule}{name}");
let filter_range = 0..name.len();
let display_range = defmodule.len()..defmodule.len() + name.len();
(code, filter_range, display_range)
}
SymbolKind::Function | SymbolKind::Constant => {
let def = "def ";
let code = format!("{def}{name}");
let filter_range = 0..name.len();
let display_range = def.len()..def.len() + name.len();
(code, filter_range, display_range)
}
_ => return None,
};
Some(CodeLabel {
spans: vec![CodeLabelSpan::code_range(display_range)],
filter_range: filter_range.into(),
code,
})
}
}

167
extensions/elixir/src/language_servers/lexical.rs
View file

@ -1,167 +0,0 @@
use std::fs;
use zed::lsp::{Completion, CompletionKind, Symbol};
use zed::{CodeLabel, CodeLabelSpan, LanguageServerId};
use zed_extension_api::settings::LspSettings;
use zed_extension_api::{self as zed, Result};
pub struct LexicalBinary {
pub path: String,
pub args: Option<Vec<String>>,
}
pub struct Lexical {
cached_binary_path: Option<String>,
}
impl Lexical {
pub const LANGUAGE_SERVER_ID: &'static str = "lexical";
pub fn new() -> Self {
Self {
cached_binary_path: None,
}
}
pub fn language_server_binary(
&mut self,
language_server_id: &LanguageServerId,
worktree: &zed::Worktree,
) -> Result<LexicalBinary> {
let binary_settings = LspSettings::for_worktree("lexical", worktree)
.ok()
.and_then(|lsp_settings| lsp_settings.binary);
let binary_args = binary_settings
.as_ref()
.and_then(|binary_settings| binary_settings.arguments.clone());
if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
return Ok(LexicalBinary {
path,
args: binary_args,
});
}
if let Some(path) = worktree.which("lexical") {
return Ok(LexicalBinary {
path,
args: binary_args,
});
}
if let Some(path) = &self.cached_binary_path {
if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
return Ok(LexicalBinary {
path: path.clone(),
args: binary_args,
});
}
}
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::CheckingForUpdate,
);
let release = zed::latest_github_release(
"lexical-lsp/lexical",
zed::GithubReleaseOptions {
require_assets: true,
pre_release: false,
},
)?;
let asset_name = format!("lexical-{version}.zip", version = release.version);
let asset = release
.assets
.iter()
.find(|asset| asset.name == asset_name)
.ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
let version_dir = format!("lexical-{}", release.version);
let binary_path = format!("{version_dir}/lexical/bin/start_lexical.sh");
if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::Downloading,
);
zed::download_file(
&asset.download_url,
&version_dir,
zed::DownloadedFileType::Zip,
)
.map_err(|e| format!("failed to download file: {e}"))?;
zed::make_file_executable(&binary_path)?;
zed::make_file_executable(&format!("{version_dir}/lexical/bin/debug_shell.sh"))?;
zed::make_file_executable(&format!("{version_dir}/lexical/priv/port_wrapper.sh"))?;
let entries =
fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
for entry in entries {
let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
if entry.file_name().to_str() != Some(&version_dir) {
fs::remove_dir_all(entry.path()).ok();
}
}
}
self.cached_binary_path = Some(binary_path.clone());
Ok(LexicalBinary {
path: binary_path,
args: binary_args,
})
}
pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
match completion.kind? {
CompletionKind::Module
| CompletionKind::Class
| CompletionKind::Interface
| CompletionKind::Struct => {
let name = completion.label;
let defmodule = "defmodule ";
let code = format!("{defmodule}{name}");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(
defmodule.len()..defmodule.len() + name.len(),
)],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Function | CompletionKind::Constant => {
let name = completion.label;
let def = "def ";
let code = format!("{def}{name}");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(def.len()..def.len() + name.len())],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Operator => {
let name = completion.label;
let def_a = "def a ";
let code = format!("{def_a}{name} b");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(
def_a.len()..def_a.len() + name.len(),
)],
filter_range: (0..name.len()).into(),
})
}
_ => None,
}
}
pub fn label_for_symbol(&self, _symbol: Symbol) -> Option<CodeLabel> {
None
}
}

180
extensions/elixir/src/language_servers/next_ls.rs
View file

@ -1,180 +0,0 @@
use std::fs;
use zed::lsp::{Completion, CompletionKind, Symbol, SymbolKind};
use zed::{CodeLabel, CodeLabelSpan, LanguageServerId};
use zed_extension_api::{self as zed, Result};
pub struct NextLs {
cached_binary_path: Option<String>,
}
impl NextLs {
pub const LANGUAGE_SERVER_ID: &'static str = "next-ls";
pub fn new() -> Self {
Self {
cached_binary_path: None,
}
}
pub fn language_server_binary_path(
&mut self,
language_server_id: &LanguageServerId,
worktree: &zed::Worktree,
) -> Result<String> {
if let Some(path) = worktree.which("nextls") {
return Ok(path);
}
if let Some(path) = &self.cached_binary_path {
if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
return Ok(path.clone());
}
}
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::CheckingForUpdate,
);
let release = zed::latest_github_release(
"elixir-tools/next-ls",
zed::GithubReleaseOptions {
require_assets: true,
pre_release: false,
},
)?;
let (platform, arch) = zed::current_platform();
let asset_name = format!(
"next_ls_{os}_{arch}{extension}",
os = match platform {
zed::Os::Mac => "darwin",
zed::Os::Linux => "linux",
zed::Os::Windows => "windows",
},
arch = match arch {
zed::Architecture::Aarch64 => "arm64",
zed::Architecture::X8664 => "amd64",
zed::Architecture::X86 =>
return Err(format!("unsupported architecture: {arch:?}")),
},
extension = match platform {
zed::Os::Mac | zed::Os::Linux => "",
zed::Os::Windows => ".exe",
}
);
let asset = release
.assets
.iter()
.find(|asset| asset.name == asset_name)
.ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
let version_dir = format!("next-ls-{}", release.version);
fs::create_dir_all(&version_dir).map_err(|e| format!("failed to create directory: {e}"))?;
let binary_path = format!("{version_dir}/next-ls");
if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
zed::set_language_server_installation_status(
language_server_id,
&zed::LanguageServerInstallationStatus::Downloading,
);
zed::download_file(
&asset.download_url,
&binary_path,
zed::DownloadedFileType::Uncompressed,
)
.map_err(|e| format!("failed to download file: {e}"))?;
zed::make_file_executable(&binary_path)?;
let entries =
fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
for entry in entries {
let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
if entry.file_name().to_str() != Some(&version_dir) {
fs::remove_dir_all(entry.path()).ok();
}
}
}
self.cached_binary_path = Some(binary_path.clone());
Ok(binary_path)
}
pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
match completion.kind? {
CompletionKind::Module
| CompletionKind::Class
| CompletionKind::Interface
| CompletionKind::Struct => {
let name = completion.label;
let defmodule = "defmodule ";
let code = format!("{defmodule}{name}");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(
defmodule.len()..defmodule.len() + name.len(),
)],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Function | CompletionKind::Constant => {
let name = completion.label;
let def = "def ";
let code = format!("{def}{name}");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(def.len()..def.len() + name.len())],
filter_range: (0..name.len()).into(),
})
}
CompletionKind::Operator => {
let name = completion.label;
let def_a = "def a ";
let code = format!("{def_a}{name} b");
Some(CodeLabel {
code,
spans: vec![CodeLabelSpan::code_range(
def_a.len()..def_a.len() + name.len(),
)],
filter_range: (0..name.len()).into(),
})
}
_ => None,
}
}
pub fn label_for_symbol(&self, symbol: Symbol) -> Option<CodeLabel> {
let name = &symbol.name;
let (code, filter_range, display_range) = match symbol.kind {
SymbolKind::Module | SymbolKind::Class | SymbolKind::Interface | SymbolKind::Struct => {
let defmodule = "defmodule ";
let code = format!("{defmodule}{name}");
let filter_range = 0..name.len();
let display_range = defmodule.len()..defmodule.len() + name.len();
(code, filter_range, display_range)
}
SymbolKind::Function | SymbolKind::Constant => {
let def = "def ";
let code = format!("{def}{name}");
let filter_range = 0..name.len();
let display_range = def.len()..def.len() + name.len();
(code, filter_range, display_range)
}
_ => return None,
};
Some(CodeLabel {
spans: vec![CodeLabelSpan::code_range(display_range)],
filter_range: filter_range.into(),
code,
})
}
}