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