1//! Provides `language`-related settings.
2
3use crate::{File, Language, LanguageServerName};
4use anyhow::Result;
5use collections::{HashMap, HashSet};
6use globset::GlobMatcher;
7use gpui::AppContext;
8use itertools::{Either, Itertools};
9use schemars::{
10 schema::{InstanceType, ObjectValidation, Schema, SchemaObject},
11 JsonSchema,
12};
13use serde::{Deserialize, Serialize};
14use settings::{Settings, SettingsLocation, SettingsSources};
15use std::{num::NonZeroU32, path::Path, sync::Arc};
16
17impl<'a> Into<SettingsLocation<'a>> for &'a dyn File {
18 fn into(self) -> SettingsLocation<'a> {
19 SettingsLocation {
20 worktree_id: self.worktree_id(),
21 path: self.path().as_ref(),
22 }
23 }
24}
25
26/// Initializes the language settings.
27pub fn init(cx: &mut AppContext) {
28 AllLanguageSettings::register(cx);
29}
30
31/// Returns the settings for the specified language from the provided file.
32pub fn language_settings<'a>(
33 language: Option<&Arc<Language>>,
34 file: Option<&Arc<dyn File>>,
35 cx: &'a AppContext,
36) -> &'a LanguageSettings {
37 let language_name = language.map(|l| l.name());
38 all_language_settings(file, cx).language(language_name.as_deref())
39}
40
41/// Returns the settings for all languages from the provided file.
42pub fn all_language_settings<'a>(
43 file: Option<&Arc<dyn File>>,
44 cx: &'a AppContext,
45) -> &'a AllLanguageSettings {
46 let location = file.map(|f| f.as_ref().into());
47 AllLanguageSettings::get(location, cx)
48}
49
50/// The settings for all languages.
51#[derive(Debug, Clone)]
52pub struct AllLanguageSettings {
53 /// The settings for GitHub Copilot.
54 pub copilot: CopilotSettings,
55 defaults: LanguageSettings,
56 languages: HashMap<Arc<str>, LanguageSettings>,
57 pub(crate) file_types: HashMap<Arc<str>, Vec<String>>,
58}
59
60/// The settings for a particular language.
61#[derive(Debug, Clone, Deserialize)]
62pub struct LanguageSettings {
63 /// How many columns a tab should occupy.
64 pub tab_size: NonZeroU32,
65 /// Whether to indent lines using tab characters, as opposed to multiple
66 /// spaces.
67 pub hard_tabs: bool,
68 /// How to soft-wrap long lines of text.
69 pub soft_wrap: SoftWrap,
70 /// The column at which to soft-wrap lines, for buffers where soft-wrap
71 /// is enabled.
72 pub preferred_line_length: u32,
73 /// Whether to show wrap guides in the editor. Setting this to true will
74 /// show a guide at the 'preferred_line_length' value if softwrap is set to
75 /// 'preferred_line_length', and will show any additional guides as specified
76 /// by the 'wrap_guides' setting.
77 pub show_wrap_guides: bool,
78 /// Character counts at which to show wrap guides in the editor.
79 pub wrap_guides: Vec<usize>,
80 /// Whether or not to perform a buffer format before saving.
81 pub format_on_save: FormatOnSave,
82 /// Whether or not to remove any trailing whitespace from lines of a buffer
83 /// before saving it.
84 pub remove_trailing_whitespace_on_save: bool,
85 /// Whether or not to ensure there's a single newline at the end of a buffer
86 /// when saving it.
87 pub ensure_final_newline_on_save: bool,
88 /// How to perform a buffer format.
89 pub formatter: Formatter,
90 /// Zed's Prettier integration settings.
91 /// If Prettier is enabled, Zed will use this for its Prettier instance for any applicable file, if
92 /// the project has no other Prettier installed.
93 pub prettier: HashMap<String, serde_json::Value>,
94 /// Whether to use language servers to provide code intelligence.
95 pub enable_language_server: bool,
96 /// The list of language servers to use (or disable) for this language.
97 ///
98 /// This array should consist of language server IDs, as well as the following
99 /// special tokens:
100 /// - `"!<language_server_id>"` - A language server ID prefixed with a `!` will be disabled.
101 /// - `"..."` - A placeholder to refer to the **rest** of the registered language servers for this language.
102 pub language_servers: Vec<Arc<str>>,
103 /// Controls whether Copilot provides suggestion immediately (true)
104 /// or waits for a `copilot::Toggle` (false).
105 pub show_copilot_suggestions: bool,
106 /// Whether to show tabs and spaces in the editor.
107 pub show_whitespaces: ShowWhitespaceSetting,
108 /// Whether to start a new line with a comment when a previous line is a comment as well.
109 pub extend_comment_on_newline: bool,
110 /// Inlay hint related settings.
111 pub inlay_hints: InlayHintSettings,
112 /// Whether to automatically close brackets.
113 pub use_autoclose: bool,
114 // Controls how the editor handles the autoclosed characters.
115 pub always_treat_brackets_as_autoclosed: bool,
116 /// Which code actions to run on save
117 pub code_actions_on_format: HashMap<String, bool>,
118}
119
120impl LanguageSettings {
121 /// A token representing the rest of the available language servers.
122 const REST_OF_LANGUAGE_SERVERS: &'static str = "...";
123
124 /// Returns the customized list of language servers from the list of
125 /// available language servers.
126 pub fn customized_language_servers(
127 &self,
128 available_language_servers: &[LanguageServerName],
129 ) -> Vec<LanguageServerName> {
130 Self::resolve_language_servers(&self.language_servers, available_language_servers)
131 }
132
133 pub(crate) fn resolve_language_servers(
134 configured_language_servers: &[Arc<str>],
135 available_language_servers: &[LanguageServerName],
136 ) -> Vec<LanguageServerName> {
137 let (disabled_language_servers, enabled_language_servers): (Vec<Arc<str>>, Vec<Arc<str>>) =
138 configured_language_servers.iter().partition_map(
139 |language_server| match language_server.strip_prefix('!') {
140 Some(disabled) => Either::Left(disabled.into()),
141 None => Either::Right(language_server.clone()),
142 },
143 );
144
145 let rest = available_language_servers
146 .into_iter()
147 .filter(|&available_language_server| {
148 !disabled_language_servers.contains(&&available_language_server.0)
149 && !enabled_language_servers.contains(&&available_language_server.0)
150 })
151 .cloned()
152 .collect::<Vec<_>>();
153
154 enabled_language_servers
155 .into_iter()
156 .flat_map(|language_server| {
157 if language_server.as_ref() == Self::REST_OF_LANGUAGE_SERVERS {
158 rest.clone()
159 } else {
160 vec![LanguageServerName(language_server.clone())]
161 }
162 })
163 .collect::<Vec<_>>()
164 }
165}
166
167/// The settings for [GitHub Copilot](https://github.com/features/copilot).
168#[derive(Clone, Debug, Default)]
169pub struct CopilotSettings {
170 /// Whether Copilot is enabled.
171 pub feature_enabled: bool,
172 /// A list of globs representing files that Copilot should be disabled for.
173 pub disabled_globs: Vec<GlobMatcher>,
174}
175
176/// The settings for all languages.
177#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
178pub struct AllLanguageSettingsContent {
179 /// The settings for enabling/disabling features.
180 #[serde(default)]
181 pub features: Option<FeaturesContent>,
182 /// The settings for GitHub Copilot.
183 #[serde(default)]
184 pub copilot: Option<CopilotSettingsContent>,
185 /// The default language settings.
186 #[serde(flatten)]
187 pub defaults: LanguageSettingsContent,
188 /// The settings for individual languages.
189 #[serde(default, alias = "language_overrides")]
190 pub languages: HashMap<Arc<str>, LanguageSettingsContent>,
191 /// Settings for associating file extensions and filenames
192 /// with languages.
193 #[serde(default)]
194 pub file_types: HashMap<Arc<str>, Vec<String>>,
195}
196
197/// The settings for a particular language.
198#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
199pub struct LanguageSettingsContent {
200 /// How many columns a tab should occupy.
201 ///
202 /// Default: 4
203 #[serde(default)]
204 pub tab_size: Option<NonZeroU32>,
205 /// Whether to indent lines using tab characters, as opposed to multiple
206 /// spaces.
207 ///
208 /// Default: false
209 #[serde(default)]
210 pub hard_tabs: Option<bool>,
211 /// How to soft-wrap long lines of text.
212 ///
213 /// Default: none
214 #[serde(default)]
215 pub soft_wrap: Option<SoftWrap>,
216 /// The column at which to soft-wrap lines, for buffers where soft-wrap
217 /// is enabled.
218 ///
219 /// Default: 80
220 #[serde(default)]
221 pub preferred_line_length: Option<u32>,
222 /// Whether to show wrap guides in the editor. Setting this to true will
223 /// show a guide at the 'preferred_line_length' value if softwrap is set to
224 /// 'preferred_line_length', and will show any additional guides as specified
225 /// by the 'wrap_guides' setting.
226 ///
227 /// Default: true
228 #[serde(default)]
229 pub show_wrap_guides: Option<bool>,
230 /// Character counts at which to show wrap guides in the editor.
231 ///
232 /// Default: []
233 #[serde(default)]
234 pub wrap_guides: Option<Vec<usize>>,
235 /// Whether or not to perform a buffer format before saving.
236 ///
237 /// Default: on
238 #[serde(default)]
239 pub format_on_save: Option<FormatOnSave>,
240 /// Whether or not to remove any trailing whitespace from lines of a buffer
241 /// before saving it.
242 ///
243 /// Default: true
244 #[serde(default)]
245 pub remove_trailing_whitespace_on_save: Option<bool>,
246 /// Whether or not to ensure there's a single newline at the end of a buffer
247 /// when saving it.
248 ///
249 /// Default: true
250 #[serde(default)]
251 pub ensure_final_newline_on_save: Option<bool>,
252 /// How to perform a buffer format.
253 ///
254 /// Default: auto
255 #[serde(default)]
256 pub formatter: Option<Formatter>,
257 /// Zed's Prettier integration settings.
258 /// If Prettier is enabled, Zed will use this for its Prettier instance for any applicable file, if
259 /// the project has no other Prettier installed.
260 ///
261 /// Default: {}
262 #[serde(default)]
263 pub prettier: Option<HashMap<String, serde_json::Value>>,
264 /// Whether to use language servers to provide code intelligence.
265 ///
266 /// Default: true
267 #[serde(default)]
268 pub enable_language_server: Option<bool>,
269 /// The list of language servers to use (or disable) for this language.
270 ///
271 /// This array should consist of language server IDs, as well as the following
272 /// special tokens:
273 /// - `"!<language_server_id>"` - A language server ID prefixed with a `!` will be disabled.
274 /// - `"..."` - A placeholder to refer to the **rest** of the registered language servers for this language.
275 ///
276 /// Default: ["..."]
277 #[serde(default)]
278 pub language_servers: Option<Vec<Arc<str>>>,
279 /// Controls whether Copilot provides suggestion immediately (true)
280 /// or waits for a `copilot::Toggle` (false).
281 ///
282 /// Default: true
283 #[serde(default)]
284 pub show_copilot_suggestions: Option<bool>,
285 /// Whether to show tabs and spaces in the editor.
286 #[serde(default)]
287 pub show_whitespaces: Option<ShowWhitespaceSetting>,
288 /// Whether to start a new line with a comment when a previous line is a comment as well.
289 ///
290 /// Default: true
291 #[serde(default)]
292 pub extend_comment_on_newline: Option<bool>,
293 /// Inlay hint related settings.
294 #[serde(default)]
295 pub inlay_hints: Option<InlayHintSettings>,
296 /// Whether to automatically type closing characters for you. For example,
297 /// when you type (, Zed will automatically add a closing ) at the correct position.
298 ///
299 /// Default: true
300 pub use_autoclose: Option<bool>,
301 // Controls how the editor handles the autoclosed characters.
302 // When set to `false`(default), skipping over and auto-removing of the closing characters
303 // happen only for auto-inserted characters.
304 // Otherwise(when `true`), the closing characters are always skipped over and auto-removed
305 // no matter how they were inserted.
306 ///
307 /// Default: false
308 pub always_treat_brackets_as_autoclosed: Option<bool>,
309 /// Which code actions to run on save after the formatter.
310 /// These are not run if formatting is off.
311 ///
312 /// Default: {} (or {"source.organizeImports": true} for Go).
313 pub code_actions_on_format: Option<HashMap<String, bool>>,
314}
315
316/// The contents of the GitHub Copilot settings.
317#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize, JsonSchema)]
318pub struct CopilotSettingsContent {
319 /// A list of globs representing files that Copilot should be disabled for.
320 #[serde(default)]
321 pub disabled_globs: Option<Vec<String>>,
322}
323
324/// The settings for enabling/disabling features.
325#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, JsonSchema)]
326#[serde(rename_all = "snake_case")]
327pub struct FeaturesContent {
328 /// Whether the GitHub Copilot feature is enabled.
329 pub copilot: Option<bool>,
330}
331
332/// Controls the soft-wrapping behavior in the editor.
333#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
334#[serde(rename_all = "snake_case")]
335pub enum SoftWrap {
336 /// Do not soft wrap.
337 None,
338 /// Prefer a single line generally, unless an overly long line is encountered.
339 PreferLine,
340 /// Soft wrap lines that overflow the editor
341 EditorWidth,
342 /// Soft wrap lines at the preferred line length
343 PreferredLineLength,
344}
345
346/// Controls the behavior of formatting files when they are saved.
347#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
348#[serde(rename_all = "snake_case")]
349pub enum FormatOnSave {
350 /// Files should be formatted on save.
351 On,
352 /// Files should not be formatted on save.
353 Off,
354 /// Files should be formatted using the current language server.
355 LanguageServer,
356 /// The external program to use to format the files on save.
357 External {
358 /// The external program to run.
359 command: Arc<str>,
360 /// The arguments to pass to the program.
361 arguments: Arc<[String]>,
362 },
363 /// Files should be formatted using code actions executed by language servers.
364 CodeActions(HashMap<String, bool>),
365}
366
367/// Controls how whitespace should be displayedin the editor.
368#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
369#[serde(rename_all = "snake_case")]
370pub enum ShowWhitespaceSetting {
371 /// Draw whitespace only for the selected text.
372 Selection,
373 /// Do not draw any tabs or spaces.
374 None,
375 /// Draw all invisible symbols.
376 All,
377}
378
379/// Controls which formatter should be used when formatting code.
380#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
381#[serde(rename_all = "snake_case")]
382pub enum Formatter {
383 /// Format files using Zed's Prettier integration (if applicable),
384 /// or falling back to formatting via language server.
385 #[default]
386 Auto,
387 /// Format code using the current language server.
388 LanguageServer,
389 /// Format code using Zed's Prettier integration.
390 Prettier,
391 /// Format code using an external command.
392 External {
393 /// The external program to run.
394 command: Arc<str>,
395 /// The arguments to pass to the program.
396 arguments: Arc<[String]>,
397 },
398 /// Files should be formatted using code actions executed by language servers.
399 CodeActions(HashMap<String, bool>),
400}
401
402/// The settings for inlay hints.
403#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
404pub struct InlayHintSettings {
405 /// Global switch to toggle hints on and off.
406 ///
407 /// Default: false
408 #[serde(default)]
409 pub enabled: bool,
410 /// Whether type hints should be shown.
411 ///
412 /// Default: true
413 #[serde(default = "default_true")]
414 pub show_type_hints: bool,
415 /// Whether parameter hints should be shown.
416 ///
417 /// Default: true
418 #[serde(default = "default_true")]
419 pub show_parameter_hints: bool,
420 /// Whether other hints should be shown.
421 ///
422 /// Default: true
423 #[serde(default = "default_true")]
424 pub show_other_hints: bool,
425 /// Whether or not to debounce inlay hints updates after buffer edits.
426 ///
427 /// Set to 0 to disable debouncing.
428 ///
429 /// Default: 700
430 #[serde(default = "edit_debounce_ms")]
431 pub edit_debounce_ms: u64,
432 /// Whether or not to debounce inlay hints updates after buffer scrolls.
433 ///
434 /// Set to 0 to disable debouncing.
435 ///
436 /// Default: 50
437 #[serde(default = "scroll_debounce_ms")]
438 pub scroll_debounce_ms: u64,
439}
440
441fn default_true() -> bool {
442 true
443}
444
445fn edit_debounce_ms() -> u64 {
446 700
447}
448
449fn scroll_debounce_ms() -> u64 {
450 50
451}
452
453impl InlayHintSettings {
454 /// Returns the kinds of inlay hints that are enabled based on the settings.
455 pub fn enabled_inlay_hint_kinds(&self) -> HashSet<Option<InlayHintKind>> {
456 let mut kinds = HashSet::default();
457 if self.show_type_hints {
458 kinds.insert(Some(InlayHintKind::Type));
459 }
460 if self.show_parameter_hints {
461 kinds.insert(Some(InlayHintKind::Parameter));
462 }
463 if self.show_other_hints {
464 kinds.insert(None);
465 }
466 kinds
467 }
468}
469
470impl AllLanguageSettings {
471 /// Returns the [`LanguageSettings`] for the language with the specified name.
472 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
473 if let Some(name) = language_name {
474 if let Some(overrides) = self.languages.get(name) {
475 return overrides;
476 }
477 }
478 &self.defaults
479 }
480
481 /// Returns whether GitHub Copilot is enabled for the given path.
482 pub fn copilot_enabled_for_path(&self, path: &Path) -> bool {
483 !self
484 .copilot
485 .disabled_globs
486 .iter()
487 .any(|glob| glob.is_match(path))
488 }
489
490 /// Returns whether GitHub Copilot is enabled for the given language and path.
491 pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
492 if !self.copilot.feature_enabled {
493 return false;
494 }
495
496 if let Some(path) = path {
497 if !self.copilot_enabled_for_path(path) {
498 return false;
499 }
500 }
501
502 self.language(language.map(|l| l.name()).as_deref())
503 .show_copilot_suggestions
504 }
505}
506
507/// The kind of an inlay hint.
508#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
509pub enum InlayHintKind {
510 /// An inlay hint for a type.
511 Type,
512 /// An inlay hint for a parameter.
513 Parameter,
514}
515
516impl InlayHintKind {
517 /// Returns the [`InlayHintKind`] from the given name.
518 ///
519 /// Returns `None` if `name` does not match any of the expected
520 /// string representations.
521 pub fn from_name(name: &str) -> Option<Self> {
522 match name {
523 "type" => Some(InlayHintKind::Type),
524 "parameter" => Some(InlayHintKind::Parameter),
525 _ => None,
526 }
527 }
528
529 /// Returns the name of this [`InlayHintKind`].
530 pub fn name(&self) -> &'static str {
531 match self {
532 InlayHintKind::Type => "type",
533 InlayHintKind::Parameter => "parameter",
534 }
535 }
536}
537
538impl settings::Settings for AllLanguageSettings {
539 const KEY: Option<&'static str> = None;
540
541 type FileContent = AllLanguageSettingsContent;
542
543 fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
544 let default_value = sources.default;
545
546 // A default is provided for all settings.
547 let mut defaults: LanguageSettings =
548 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
549
550 let mut languages = HashMap::default();
551 for (language_name, settings) in &default_value.languages {
552 let mut language_settings = defaults.clone();
553 merge_settings(&mut language_settings, settings);
554 languages.insert(language_name.clone(), language_settings);
555 }
556
557 let mut copilot_enabled = default_value
558 .features
559 .as_ref()
560 .and_then(|f| f.copilot)
561 .ok_or_else(Self::missing_default)?;
562 let mut copilot_globs = default_value
563 .copilot
564 .as_ref()
565 .and_then(|c| c.disabled_globs.as_ref())
566 .ok_or_else(Self::missing_default)?;
567
568 let mut file_types: HashMap<Arc<str>, Vec<String>> = HashMap::default();
569 for user_settings in sources.customizations() {
570 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
571 copilot_enabled = copilot;
572 }
573 if let Some(globs) = user_settings
574 .copilot
575 .as_ref()
576 .and_then(|f| f.disabled_globs.as_ref())
577 {
578 copilot_globs = globs;
579 }
580
581 // A user's global settings override the default global settings and
582 // all default language-specific settings.
583 merge_settings(&mut defaults, &user_settings.defaults);
584 for language_settings in languages.values_mut() {
585 merge_settings(language_settings, &user_settings.defaults);
586 }
587
588 // A user's language-specific settings override default language-specific settings.
589 for (language_name, user_language_settings) in &user_settings.languages {
590 merge_settings(
591 languages
592 .entry(language_name.clone())
593 .or_insert_with(|| defaults.clone()),
594 user_language_settings,
595 );
596 }
597
598 for (language, suffixes) in &user_settings.file_types {
599 file_types
600 .entry(language.clone())
601 .or_default()
602 .extend_from_slice(suffixes);
603 }
604 }
605
606 Ok(Self {
607 copilot: CopilotSettings {
608 feature_enabled: copilot_enabled,
609 disabled_globs: copilot_globs
610 .iter()
611 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
612 .collect(),
613 },
614 defaults,
615 languages,
616 file_types,
617 })
618 }
619
620 fn json_schema(
621 generator: &mut schemars::gen::SchemaGenerator,
622 params: &settings::SettingsJsonSchemaParams,
623 _: &AppContext,
624 ) -> schemars::schema::RootSchema {
625 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
626
627 // Create a schema for a 'languages overrides' object, associating editor
628 // settings with specific languages.
629 assert!(root_schema
630 .definitions
631 .contains_key("LanguageSettingsContent"));
632
633 let languages_object_schema = SchemaObject {
634 instance_type: Some(InstanceType::Object.into()),
635 object: Some(Box::new(ObjectValidation {
636 properties: params
637 .language_names
638 .iter()
639 .map(|name| {
640 (
641 name.clone(),
642 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
643 )
644 })
645 .collect(),
646 ..Default::default()
647 })),
648 ..Default::default()
649 };
650
651 root_schema
652 .definitions
653 .extend([("Languages".into(), languages_object_schema.into())]);
654
655 root_schema
656 .schema
657 .object
658 .as_mut()
659 .unwrap()
660 .properties
661 .extend([
662 (
663 "languages".to_owned(),
664 Schema::new_ref("#/definitions/Languages".into()),
665 ),
666 // For backward compatibility
667 (
668 "language_overrides".to_owned(),
669 Schema::new_ref("#/definitions/Languages".into()),
670 ),
671 ]);
672
673 root_schema
674 }
675}
676
677fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
678 fn merge<T>(target: &mut T, value: Option<T>) {
679 if let Some(value) = value {
680 *target = value;
681 }
682 }
683
684 merge(&mut settings.tab_size, src.tab_size);
685 merge(&mut settings.hard_tabs, src.hard_tabs);
686 merge(&mut settings.soft_wrap, src.soft_wrap);
687 merge(&mut settings.use_autoclose, src.use_autoclose);
688 merge(
689 &mut settings.always_treat_brackets_as_autoclosed,
690 src.always_treat_brackets_as_autoclosed,
691 );
692 merge(&mut settings.show_wrap_guides, src.show_wrap_guides);
693 merge(&mut settings.wrap_guides, src.wrap_guides.clone());
694 merge(
695 &mut settings.code_actions_on_format,
696 src.code_actions_on_format.clone(),
697 );
698
699 merge(
700 &mut settings.preferred_line_length,
701 src.preferred_line_length,
702 );
703 merge(&mut settings.formatter, src.formatter.clone());
704 merge(&mut settings.prettier, src.prettier.clone());
705 merge(&mut settings.format_on_save, src.format_on_save.clone());
706 merge(
707 &mut settings.remove_trailing_whitespace_on_save,
708 src.remove_trailing_whitespace_on_save,
709 );
710 merge(
711 &mut settings.ensure_final_newline_on_save,
712 src.ensure_final_newline_on_save,
713 );
714 merge(
715 &mut settings.enable_language_server,
716 src.enable_language_server,
717 );
718 merge(&mut settings.language_servers, src.language_servers.clone());
719 merge(
720 &mut settings.show_copilot_suggestions,
721 src.show_copilot_suggestions,
722 );
723 merge(&mut settings.show_whitespaces, src.show_whitespaces);
724 merge(
725 &mut settings.extend_comment_on_newline,
726 src.extend_comment_on_newline,
727 );
728 merge(&mut settings.inlay_hints, src.inlay_hints);
729}
730
731#[cfg(test)]
732mod tests {
733 use super::*;
734
735 #[test]
736 pub fn test_resolve_language_servers() {
737 fn language_server_names(names: &[&str]) -> Vec<LanguageServerName> {
738 names
739 .into_iter()
740 .copied()
741 .map(|name| LanguageServerName(name.into()))
742 .collect::<Vec<_>>()
743 }
744
745 let available_language_servers = language_server_names(&[
746 "typescript-language-server",
747 "biome",
748 "deno",
749 "eslint",
750 "tailwind",
751 ]);
752
753 // A value of just `["..."]` is the same as taking all of the available language servers.
754 assert_eq!(
755 LanguageSettings::resolve_language_servers(
756 &[LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()],
757 &available_language_servers,
758 ),
759 available_language_servers
760 );
761
762 // Referencing one of the available language servers will change its order.
763 assert_eq!(
764 LanguageSettings::resolve_language_servers(
765 &[
766 "biome".into(),
767 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into(),
768 "deno".into()
769 ],
770 &available_language_servers
771 ),
772 language_server_names(&[
773 "biome",
774 "typescript-language-server",
775 "eslint",
776 "tailwind",
777 "deno",
778 ])
779 );
780
781 // Negating an available language server removes it from the list.
782 assert_eq!(
783 LanguageSettings::resolve_language_servers(
784 &[
785 "deno".into(),
786 "!typescript-language-server".into(),
787 "!biome".into(),
788 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()
789 ],
790 &available_language_servers
791 ),
792 language_server_names(&["deno", "eslint", "tailwind"])
793 );
794
795 // Adding a language server not in the list of available language servers adds it to the list.
796 assert_eq!(
797 LanguageSettings::resolve_language_servers(
798 &[
799 "my-cool-language-server".into(),
800 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()
801 ],
802 &available_language_servers
803 ),
804 language_server_names(&[
805 "my-cool-language-server",
806 "typescript-language-server",
807 "biome",
808 "deno",
809 "eslint",
810 "tailwind",
811 ])
812 );
813 }
814}