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 /// Soft wrap lines that overflow the editor
339 EditorWidth,
340 /// Soft wrap lines at the preferred line length
341 PreferredLineLength,
342}
343
344/// Controls the behavior of formatting files when they are saved.
345#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
346#[serde(rename_all = "snake_case")]
347pub enum FormatOnSave {
348 /// Files should be formatted on save.
349 On,
350 /// Files should not be formatted on save.
351 Off,
352 /// Files should be formatted using the current language server.
353 LanguageServer,
354 /// The external program to use to format the files on save.
355 External {
356 /// The external program to run.
357 command: Arc<str>,
358 /// The arguments to pass to the program.
359 arguments: Arc<[String]>,
360 },
361 /// Files should be formatted using code actions executed by language servers.
362 CodeActions(HashMap<String, bool>),
363}
364
365/// Controls how whitespace should be displayedin the editor.
366#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
367#[serde(rename_all = "snake_case")]
368pub enum ShowWhitespaceSetting {
369 /// Draw whitespace only for the selected text.
370 Selection,
371 /// Do not draw any tabs or spaces.
372 None,
373 /// Draw all invisible symbols.
374 All,
375}
376
377/// Controls which formatter should be used when formatting code.
378#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
379#[serde(rename_all = "snake_case")]
380pub enum Formatter {
381 /// Format files using Zed's Prettier integration (if applicable),
382 /// or falling back to formatting via language server.
383 #[default]
384 Auto,
385 /// Format code using the current language server.
386 LanguageServer,
387 /// Format code using Zed's Prettier integration.
388 Prettier,
389 /// Format code using an external command.
390 External {
391 /// The external program to run.
392 command: Arc<str>,
393 /// The arguments to pass to the program.
394 arguments: Arc<[String]>,
395 },
396 /// Files should be formatted using code actions executed by language servers.
397 CodeActions(HashMap<String, bool>),
398}
399
400/// The settings for inlay hints.
401#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
402pub struct InlayHintSettings {
403 /// Global switch to toggle hints on and off.
404 ///
405 /// Default: false
406 #[serde(default)]
407 pub enabled: bool,
408 /// Whether type hints should be shown.
409 ///
410 /// Default: true
411 #[serde(default = "default_true")]
412 pub show_type_hints: bool,
413 /// Whether parameter hints should be shown.
414 ///
415 /// Default: true
416 #[serde(default = "default_true")]
417 pub show_parameter_hints: bool,
418 /// Whether other hints should be shown.
419 ///
420 /// Default: true
421 #[serde(default = "default_true")]
422 pub show_other_hints: bool,
423 /// Whether or not to debounce inlay hints updates after buffer edits.
424 ///
425 /// Set to 0 to disable debouncing.
426 ///
427 /// Default: 700
428 #[serde(default = "edit_debounce_ms")]
429 pub edit_debounce_ms: u64,
430 /// Whether or not to debounce inlay hints updates after buffer scrolls.
431 ///
432 /// Set to 0 to disable debouncing.
433 ///
434 /// Default: 50
435 #[serde(default = "scroll_debounce_ms")]
436 pub scroll_debounce_ms: u64,
437}
438
439fn default_true() -> bool {
440 true
441}
442
443fn edit_debounce_ms() -> u64 {
444 700
445}
446
447fn scroll_debounce_ms() -> u64 {
448 50
449}
450
451impl InlayHintSettings {
452 /// Returns the kinds of inlay hints that are enabled based on the settings.
453 pub fn enabled_inlay_hint_kinds(&self) -> HashSet<Option<InlayHintKind>> {
454 let mut kinds = HashSet::default();
455 if self.show_type_hints {
456 kinds.insert(Some(InlayHintKind::Type));
457 }
458 if self.show_parameter_hints {
459 kinds.insert(Some(InlayHintKind::Parameter));
460 }
461 if self.show_other_hints {
462 kinds.insert(None);
463 }
464 kinds
465 }
466}
467
468impl AllLanguageSettings {
469 /// Returns the [`LanguageSettings`] for the language with the specified name.
470 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
471 if let Some(name) = language_name {
472 if let Some(overrides) = self.languages.get(name) {
473 return overrides;
474 }
475 }
476 &self.defaults
477 }
478
479 /// Returns whether GitHub Copilot is enabled for the given path.
480 pub fn copilot_enabled_for_path(&self, path: &Path) -> bool {
481 !self
482 .copilot
483 .disabled_globs
484 .iter()
485 .any(|glob| glob.is_match(path))
486 }
487
488 /// Returns whether GitHub Copilot is enabled for the given language and path.
489 pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
490 if !self.copilot.feature_enabled {
491 return false;
492 }
493
494 if let Some(path) = path {
495 if !self.copilot_enabled_for_path(path) {
496 return false;
497 }
498 }
499
500 self.language(language.map(|l| l.name()).as_deref())
501 .show_copilot_suggestions
502 }
503}
504
505/// The kind of an inlay hint.
506#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
507pub enum InlayHintKind {
508 /// An inlay hint for a type.
509 Type,
510 /// An inlay hint for a parameter.
511 Parameter,
512}
513
514impl InlayHintKind {
515 /// Returns the [`InlayHintKind`] from the given name.
516 ///
517 /// Returns `None` if `name` does not match any of the expected
518 /// string representations.
519 pub fn from_name(name: &str) -> Option<Self> {
520 match name {
521 "type" => Some(InlayHintKind::Type),
522 "parameter" => Some(InlayHintKind::Parameter),
523 _ => None,
524 }
525 }
526
527 /// Returns the name of this [`InlayHintKind`].
528 pub fn name(&self) -> &'static str {
529 match self {
530 InlayHintKind::Type => "type",
531 InlayHintKind::Parameter => "parameter",
532 }
533 }
534}
535
536impl settings::Settings for AllLanguageSettings {
537 const KEY: Option<&'static str> = None;
538
539 type FileContent = AllLanguageSettingsContent;
540
541 fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
542 let default_value = sources.default;
543
544 // A default is provided for all settings.
545 let mut defaults: LanguageSettings =
546 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
547
548 let mut languages = HashMap::default();
549 for (language_name, settings) in &default_value.languages {
550 let mut language_settings = defaults.clone();
551 merge_settings(&mut language_settings, settings);
552 languages.insert(language_name.clone(), language_settings);
553 }
554
555 let mut copilot_enabled = default_value
556 .features
557 .as_ref()
558 .and_then(|f| f.copilot)
559 .ok_or_else(Self::missing_default)?;
560 let mut copilot_globs = default_value
561 .copilot
562 .as_ref()
563 .and_then(|c| c.disabled_globs.as_ref())
564 .ok_or_else(Self::missing_default)?;
565
566 let mut file_types: HashMap<Arc<str>, Vec<String>> = HashMap::default();
567 for user_settings in sources.customizations() {
568 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
569 copilot_enabled = copilot;
570 }
571 if let Some(globs) = user_settings
572 .copilot
573 .as_ref()
574 .and_then(|f| f.disabled_globs.as_ref())
575 {
576 copilot_globs = globs;
577 }
578
579 // A user's global settings override the default global settings and
580 // all default language-specific settings.
581 merge_settings(&mut defaults, &user_settings.defaults);
582 for language_settings in languages.values_mut() {
583 merge_settings(language_settings, &user_settings.defaults);
584 }
585
586 // A user's language-specific settings override default language-specific settings.
587 for (language_name, user_language_settings) in &user_settings.languages {
588 merge_settings(
589 languages
590 .entry(language_name.clone())
591 .or_insert_with(|| defaults.clone()),
592 user_language_settings,
593 );
594 }
595
596 for (language, suffixes) in &user_settings.file_types {
597 file_types
598 .entry(language.clone())
599 .or_default()
600 .extend_from_slice(suffixes);
601 }
602 }
603
604 Ok(Self {
605 copilot: CopilotSettings {
606 feature_enabled: copilot_enabled,
607 disabled_globs: copilot_globs
608 .iter()
609 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
610 .collect(),
611 },
612 defaults,
613 languages,
614 file_types,
615 })
616 }
617
618 fn json_schema(
619 generator: &mut schemars::gen::SchemaGenerator,
620 params: &settings::SettingsJsonSchemaParams,
621 _: &AppContext,
622 ) -> schemars::schema::RootSchema {
623 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
624
625 // Create a schema for a 'languages overrides' object, associating editor
626 // settings with specific languages.
627 assert!(root_schema
628 .definitions
629 .contains_key("LanguageSettingsContent"));
630
631 let languages_object_schema = SchemaObject {
632 instance_type: Some(InstanceType::Object.into()),
633 object: Some(Box::new(ObjectValidation {
634 properties: params
635 .language_names
636 .iter()
637 .map(|name| {
638 (
639 name.clone(),
640 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
641 )
642 })
643 .collect(),
644 ..Default::default()
645 })),
646 ..Default::default()
647 };
648
649 root_schema
650 .definitions
651 .extend([("Languages".into(), languages_object_schema.into())]);
652
653 root_schema
654 .schema
655 .object
656 .as_mut()
657 .unwrap()
658 .properties
659 .extend([
660 (
661 "languages".to_owned(),
662 Schema::new_ref("#/definitions/Languages".into()),
663 ),
664 // For backward compatibility
665 (
666 "language_overrides".to_owned(),
667 Schema::new_ref("#/definitions/Languages".into()),
668 ),
669 ]);
670
671 root_schema
672 }
673}
674
675fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
676 fn merge<T>(target: &mut T, value: Option<T>) {
677 if let Some(value) = value {
678 *target = value;
679 }
680 }
681
682 merge(&mut settings.tab_size, src.tab_size);
683 merge(&mut settings.hard_tabs, src.hard_tabs);
684 merge(&mut settings.soft_wrap, src.soft_wrap);
685 merge(&mut settings.use_autoclose, src.use_autoclose);
686 merge(
687 &mut settings.always_treat_brackets_as_autoclosed,
688 src.always_treat_brackets_as_autoclosed,
689 );
690 merge(&mut settings.show_wrap_guides, src.show_wrap_guides);
691 merge(&mut settings.wrap_guides, src.wrap_guides.clone());
692 merge(
693 &mut settings.code_actions_on_format,
694 src.code_actions_on_format.clone(),
695 );
696
697 merge(
698 &mut settings.preferred_line_length,
699 src.preferred_line_length,
700 );
701 merge(&mut settings.formatter, src.formatter.clone());
702 merge(&mut settings.prettier, src.prettier.clone());
703 merge(&mut settings.format_on_save, src.format_on_save.clone());
704 merge(
705 &mut settings.remove_trailing_whitespace_on_save,
706 src.remove_trailing_whitespace_on_save,
707 );
708 merge(
709 &mut settings.ensure_final_newline_on_save,
710 src.ensure_final_newline_on_save,
711 );
712 merge(
713 &mut settings.enable_language_server,
714 src.enable_language_server,
715 );
716 merge(&mut settings.language_servers, src.language_servers.clone());
717 merge(
718 &mut settings.show_copilot_suggestions,
719 src.show_copilot_suggestions,
720 );
721 merge(&mut settings.show_whitespaces, src.show_whitespaces);
722 merge(
723 &mut settings.extend_comment_on_newline,
724 src.extend_comment_on_newline,
725 );
726 merge(&mut settings.inlay_hints, src.inlay_hints);
727}
728
729#[cfg(test)]
730mod tests {
731 use super::*;
732
733 #[test]
734 pub fn test_resolve_language_servers() {
735 fn language_server_names(names: &[&str]) -> Vec<LanguageServerName> {
736 names
737 .into_iter()
738 .copied()
739 .map(|name| LanguageServerName(name.into()))
740 .collect::<Vec<_>>()
741 }
742
743 let available_language_servers = language_server_names(&[
744 "typescript-language-server",
745 "biome",
746 "deno",
747 "eslint",
748 "tailwind",
749 ]);
750
751 // A value of just `["..."]` is the same as taking all of the available language servers.
752 assert_eq!(
753 LanguageSettings::resolve_language_servers(
754 &[LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()],
755 &available_language_servers,
756 ),
757 available_language_servers
758 );
759
760 // Referencing one of the available language servers will change its order.
761 assert_eq!(
762 LanguageSettings::resolve_language_servers(
763 &[
764 "biome".into(),
765 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into(),
766 "deno".into()
767 ],
768 &available_language_servers
769 ),
770 language_server_names(&[
771 "biome",
772 "typescript-language-server",
773 "eslint",
774 "tailwind",
775 "deno",
776 ])
777 );
778
779 // Negating an available language server removes it from the list.
780 assert_eq!(
781 LanguageSettings::resolve_language_servers(
782 &[
783 "deno".into(),
784 "!typescript-language-server".into(),
785 "!biome".into(),
786 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()
787 ],
788 &available_language_servers
789 ),
790 language_server_names(&["deno", "eslint", "tailwind"])
791 );
792 }
793}