1use zed::lsp::CompletionKind;
  2use zed::settings::LspSettings;
  3use zed::{CodeLabel, CodeLabelSpan};
  4use zed_extension_api::{self as zed, serde_json, Result};
  5
  6struct DartBinary {
  7    pub path: String,
  8    pub args: Option<Vec<String>>,
  9}
 10
 11struct DartExtension;
 12
 13impl DartExtension {
 14    fn language_server_binary(
 15        &mut self,
 16        _language_server_id: &zed::LanguageServerId,
 17        worktree: &zed::Worktree,
 18    ) -> Result<DartBinary> {
 19        let binary_settings = LspSettings::for_worktree("dart", worktree)
 20            .ok()
 21            .and_then(|lsp_settings| lsp_settings.binary);
 22        let binary_args = binary_settings
 23            .as_ref()
 24            .and_then(|binary_settings| binary_settings.arguments.clone());
 25
 26        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
 27            return Ok(DartBinary {
 28                path,
 29                args: binary_args,
 30            });
 31        }
 32
 33        if let Some(path) = worktree.which("dart") {
 34            return Ok(DartBinary {
 35                path,
 36                args: binary_args,
 37            });
 38        }
 39
 40        Err(
 41            "dart must be installed from dart.dev/get-dart or pointed to by the LSP binary settings"
 42                .to_string(),
 43        )
 44    }
 45}
 46
 47impl zed::Extension for DartExtension {
 48    fn new() -> Self {
 49        Self
 50    }
 51
 52    fn language_server_command(
 53        &mut self,
 54        language_server_id: &zed::LanguageServerId,
 55        worktree: &zed::Worktree,
 56    ) -> Result<zed::Command> {
 57        let dart_binary = self.language_server_binary(language_server_id, worktree)?;
 58
 59        Ok(zed::Command {
 60            command: dart_binary.path,
 61            args: dart_binary.args.unwrap_or_else(|| {
 62                vec!["language-server".to_string(), "--protocol=lsp".to_string()]
 63            }),
 64            env: Default::default(),
 65        })
 66    }
 67
 68    fn language_server_workspace_configuration(
 69        &mut self,
 70        _language_server_id: &zed::LanguageServerId,
 71        worktree: &zed::Worktree,
 72    ) -> Result<Option<serde_json::Value>> {
 73        let settings = LspSettings::for_worktree("dart", worktree)
 74            .ok()
 75            .and_then(|lsp_settings| lsp_settings.settings.clone())
 76            .unwrap_or_default();
 77
 78        Ok(Some(serde_json::json!({
 79            "dart": settings
 80        })))
 81    }
 82
 83    fn label_for_completion(
 84        &self,
 85        _language_server_id: &zed::LanguageServerId,
 86        completion: zed::lsp::Completion,
 87    ) -> Option<CodeLabel> {
 88        let arrow = " → ";
 89
 90        match completion.kind? {
 91            CompletionKind::Class => Some(CodeLabel {
 92                filter_range: (0..completion.label.len()).into(),
 93                spans: vec![CodeLabelSpan::literal(
 94                    completion.label,
 95                    Some("type".into()),
 96                )],
 97                code: String::new(),
 98            }),
 99            CompletionKind::Function | CompletionKind::Constructor | CompletionKind::Method => {
100                let mut parts = completion.detail.as_ref()?.split(arrow);
101                let (name, _) = completion.label.split_once('(')?;
102                let parameter_list = parts.next()?;
103                let return_type = parts.next()?;
104                let fn_name = " a";
105                let fat_arrow = " => ";
106                let call_expr = "();";
107
108                let code =
109                    format!("{return_type}{fn_name}{parameter_list}{fat_arrow}{name}{call_expr}");
110
111                let parameter_list_start = return_type.len() + fn_name.len();
112
113                Some(CodeLabel {
114                    spans: vec![
115                        CodeLabelSpan::code_range(
116                            code.len() - call_expr.len() - name.len()..code.len() - call_expr.len(),
117                        ),
118                        CodeLabelSpan::code_range(
119                            parameter_list_start..parameter_list_start + parameter_list.len(),
120                        ),
121                        CodeLabelSpan::literal(arrow, None),
122                        CodeLabelSpan::code_range(0..return_type.len()),
123                    ],
124                    filter_range: (0..name.len()).into(),
125                    code,
126                })
127            }
128            CompletionKind::Property => {
129                let class_start = "class A {";
130                let get = " get ";
131                let property_end = " => a; }";
132                let ty = completion.detail?;
133                let name = completion.label;
134
135                let code = format!("{class_start}{ty}{get}{name}{property_end}");
136                let name_start = class_start.len() + ty.len() + get.len();
137
138                Some(CodeLabel {
139                    spans: vec![
140                        CodeLabelSpan::code_range(name_start..name_start + name.len()),
141                        CodeLabelSpan::literal(arrow, None),
142                        CodeLabelSpan::code_range(class_start.len()..class_start.len() + ty.len()),
143                    ],
144                    filter_range: (0..name.len()).into(),
145                    code,
146                })
147            }
148            CompletionKind::Variable => {
149                let name = completion.label;
150
151                Some(CodeLabel {
152                    filter_range: (0..name.len()).into(),
153                    spans: vec![CodeLabelSpan::literal(name, Some("variable".into()))],
154                    code: String::new(),
155                })
156            }
157            _ => None,
158        }
159    }
160}
161
162zed::register_extension!(DartExtension);