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 /// Determines how indent guides are colored.
454 ///
455 /// Default: Fixed
456 #[serde(default)]
457 pub coloring: IndentGuideColoring,
458 /// Determines how indent guide backgrounds are colored.
459 ///
460 /// Default: Disabled
461 #[serde(default)]
462 pub background_coloring: IndentGuideBackgroundColoring,
463}
464
465fn line_width() -> u32 {
466 1
467}
468
469/// Determines how indent guides are colored.
470#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
471#[serde(rename_all = "snake_case")]
472pub enum IndentGuideColoring {
473 /// Do not render any lines for indent guides.
474 Disabled,
475 /// Use the same color for all indentation levels.
476 #[default]
477 Fixed,
478 /// Use a different color for each indentation level.
479 IndentAware,
480}
481
482/// Determines how indent guide backgrounds are colored.
483#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
484#[serde(rename_all = "snake_case")]
485pub enum IndentGuideBackgroundColoring {
486 /// Do not render any background for indent guides.
487 #[default]
488 Disabled,
489 /// Use a different color for each indentation level.
490 IndentAware,
491}
492
493/// The settings for inlay hints.
494#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
495pub struct InlayHintSettings {
496 /// Global switch to toggle hints on and off.
497 ///
498 /// Default: false
499 #[serde(default)]
500 pub enabled: bool,
501 /// Whether type hints should be shown.
502 ///
503 /// Default: true
504 #[serde(default = "default_true")]
505 pub show_type_hints: bool,
506 /// Whether parameter hints should be shown.
507 ///
508 /// Default: true
509 #[serde(default = "default_true")]
510 pub show_parameter_hints: bool,
511 /// Whether other hints should be shown.
512 ///
513 /// Default: true
514 #[serde(default = "default_true")]
515 pub show_other_hints: bool,
516 /// Whether or not to debounce inlay hints updates after buffer edits.
517 ///
518 /// Set to 0 to disable debouncing.
519 ///
520 /// Default: 700
521 #[serde(default = "edit_debounce_ms")]
522 pub edit_debounce_ms: u64,
523 /// Whether or not to debounce inlay hints updates after buffer scrolls.
524 ///
525 /// Set to 0 to disable debouncing.
526 ///
527 /// Default: 50
528 #[serde(default = "scroll_debounce_ms")]
529 pub scroll_debounce_ms: u64,
530}
531
532fn edit_debounce_ms() -> u64 {
533 700
534}
535
536fn scroll_debounce_ms() -> u64 {
537 50
538}
539
540impl InlayHintSettings {
541 /// Returns the kinds of inlay hints that are enabled based on the settings.
542 pub fn enabled_inlay_hint_kinds(&self) -> HashSet<Option<InlayHintKind>> {
543 let mut kinds = HashSet::default();
544 if self.show_type_hints {
545 kinds.insert(Some(InlayHintKind::Type));
546 }
547 if self.show_parameter_hints {
548 kinds.insert(Some(InlayHintKind::Parameter));
549 }
550 if self.show_other_hints {
551 kinds.insert(None);
552 }
553 kinds
554 }
555}
556
557impl AllLanguageSettings {
558 /// Returns the [`LanguageSettings`] for the language with the specified name.
559 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
560 if let Some(name) = language_name {
561 if let Some(overrides) = self.languages.get(name) {
562 return overrides;
563 }
564 }
565 &self.defaults
566 }
567
568 /// Returns whether inline completions are enabled for the given path.
569 pub fn inline_completions_enabled_for_path(&self, path: &Path) -> bool {
570 !self
571 .inline_completions
572 .disabled_globs
573 .iter()
574 .any(|glob| glob.is_match(path))
575 }
576
577 /// Returns whether inline completions are enabled for the given language and path.
578 pub fn inline_completions_enabled(
579 &self,
580 language: Option<&Arc<Language>>,
581 path: Option<&Path>,
582 ) -> bool {
583 if let Some(path) = path {
584 if !self.inline_completions_enabled_for_path(path) {
585 return false;
586 }
587 }
588
589 self.language(language.map(|l| l.name()).as_deref())
590 .show_inline_completions
591 }
592}
593
594/// The kind of an inlay hint.
595#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
596pub enum InlayHintKind {
597 /// An inlay hint for a type.
598 Type,
599 /// An inlay hint for a parameter.
600 Parameter,
601}
602
603impl InlayHintKind {
604 /// Returns the [`InlayHintKind`] from the given name.
605 ///
606 /// Returns `None` if `name` does not match any of the expected
607 /// string representations.
608 pub fn from_name(name: &str) -> Option<Self> {
609 match name {
610 "type" => Some(InlayHintKind::Type),
611 "parameter" => Some(InlayHintKind::Parameter),
612 _ => None,
613 }
614 }
615
616 /// Returns the name of this [`InlayHintKind`].
617 pub fn name(&self) -> &'static str {
618 match self {
619 InlayHintKind::Type => "type",
620 InlayHintKind::Parameter => "parameter",
621 }
622 }
623}
624
625impl settings::Settings for AllLanguageSettings {
626 const KEY: Option<&'static str> = None;
627
628 type FileContent = AllLanguageSettingsContent;
629
630 fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
631 let default_value = sources.default;
632
633 // A default is provided for all settings.
634 let mut defaults: LanguageSettings =
635 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
636
637 let mut languages = HashMap::default();
638 for (language_name, settings) in &default_value.languages {
639 let mut language_settings = defaults.clone();
640 merge_settings(&mut language_settings, settings);
641 languages.insert(language_name.clone(), language_settings);
642 }
643
644 let mut copilot_enabled = default_value.features.as_ref().and_then(|f| f.copilot);
645 let mut inline_completion_provider = default_value
646 .features
647 .as_ref()
648 .and_then(|f| f.inline_completion_provider);
649 let mut completion_globs = default_value
650 .inline_completions
651 .as_ref()
652 .and_then(|c| c.disabled_globs.as_ref())
653 .ok_or_else(Self::missing_default)?;
654
655 let mut file_types: HashMap<Arc<str>, GlobSet> = HashMap::default();
656 for user_settings in sources.customizations() {
657 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
658 copilot_enabled = Some(copilot);
659 }
660 if let Some(provider) = user_settings
661 .features
662 .as_ref()
663 .and_then(|f| f.inline_completion_provider)
664 {
665 inline_completion_provider = Some(provider);
666 }
667 if let Some(globs) = user_settings
668 .inline_completions
669 .as_ref()
670 .and_then(|f| f.disabled_globs.as_ref())
671 {
672 completion_globs = globs;
673 }
674
675 // A user's global settings override the default global settings and
676 // all default language-specific settings.
677 merge_settings(&mut defaults, &user_settings.defaults);
678 for language_settings in languages.values_mut() {
679 merge_settings(language_settings, &user_settings.defaults);
680 }
681
682 // A user's language-specific settings override default language-specific settings.
683 for (language_name, user_language_settings) in &user_settings.languages {
684 merge_settings(
685 languages
686 .entry(language_name.clone())
687 .or_insert_with(|| defaults.clone()),
688 user_language_settings,
689 );
690 }
691
692 for (language, suffixes) in &user_settings.file_types {
693 let mut builder = GlobSetBuilder::new();
694
695 for suffix in suffixes {
696 builder.add(Glob::new(suffix)?);
697 }
698
699 file_types.insert(language.clone(), builder.build()?);
700 }
701 }
702
703 Ok(Self {
704 inline_completions: InlineCompletionSettings {
705 provider: if let Some(provider) = inline_completion_provider {
706 provider
707 } else if copilot_enabled.unwrap_or(true) {
708 InlineCompletionProvider::Copilot
709 } else {
710 InlineCompletionProvider::None
711 },
712 disabled_globs: completion_globs
713 .iter()
714 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
715 .collect(),
716 },
717 defaults,
718 languages,
719 file_types,
720 })
721 }
722
723 fn json_schema(
724 generator: &mut schemars::gen::SchemaGenerator,
725 params: &settings::SettingsJsonSchemaParams,
726 _: &AppContext,
727 ) -> schemars::schema::RootSchema {
728 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
729
730 // Create a schema for a 'languages overrides' object, associating editor
731 // settings with specific languages.
732 assert!(root_schema
733 .definitions
734 .contains_key("LanguageSettingsContent"));
735
736 let languages_object_schema = SchemaObject {
737 instance_type: Some(InstanceType::Object.into()),
738 object: Some(Box::new(ObjectValidation {
739 properties: params
740 .language_names
741 .iter()
742 .map(|name| {
743 (
744 name.clone(),
745 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
746 )
747 })
748 .collect(),
749 ..Default::default()
750 })),
751 ..Default::default()
752 };
753
754 root_schema
755 .definitions
756 .extend([("Languages".into(), languages_object_schema.into())]);
757
758 root_schema
759 .schema
760 .object
761 .as_mut()
762 .unwrap()
763 .properties
764 .extend([(
765 "languages".to_owned(),
766 Schema::new_ref("#/definitions/Languages".into()),
767 )]);
768
769 root_schema
770 }
771}
772
773fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
774 fn merge<T>(target: &mut T, value: Option<T>) {
775 if let Some(value) = value {
776 *target = value;
777 }
778 }
779
780 merge(&mut settings.tab_size, src.tab_size);
781 merge(&mut settings.hard_tabs, src.hard_tabs);
782 merge(&mut settings.soft_wrap, src.soft_wrap);
783 merge(&mut settings.use_autoclose, src.use_autoclose);
784 merge(&mut settings.use_auto_surround, src.use_auto_surround);
785 merge(
786 &mut settings.always_treat_brackets_as_autoclosed,
787 src.always_treat_brackets_as_autoclosed,
788 );
789 merge(&mut settings.show_wrap_guides, src.show_wrap_guides);
790 merge(&mut settings.wrap_guides, src.wrap_guides.clone());
791 merge(&mut settings.indent_guides, src.indent_guides);
792 merge(
793 &mut settings.code_actions_on_format,
794 src.code_actions_on_format.clone(),
795 );
796 merge(&mut settings.linked_edits, src.linked_edits);
797
798 merge(
799 &mut settings.preferred_line_length,
800 src.preferred_line_length,
801 );
802 merge(&mut settings.formatter, src.formatter.clone());
803 merge(&mut settings.prettier, src.prettier.clone());
804 merge(&mut settings.format_on_save, src.format_on_save.clone());
805 merge(
806 &mut settings.remove_trailing_whitespace_on_save,
807 src.remove_trailing_whitespace_on_save,
808 );
809 merge(
810 &mut settings.ensure_final_newline_on_save,
811 src.ensure_final_newline_on_save,
812 );
813 merge(
814 &mut settings.enable_language_server,
815 src.enable_language_server,
816 );
817 merge(&mut settings.language_servers, src.language_servers.clone());
818 merge(
819 &mut settings.show_inline_completions,
820 src.show_inline_completions,
821 );
822 merge(&mut settings.show_whitespaces, src.show_whitespaces);
823 merge(
824 &mut settings.extend_comment_on_newline,
825 src.extend_comment_on_newline,
826 );
827 merge(&mut settings.inlay_hints, src.inlay_hints);
828}
829
830/// Allows to enable/disable formatting with Prettier
831/// and configure default Prettier, used when no project-level Prettier installation is found.
832/// Prettier formatting is disabled by default.
833#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
834pub struct PrettierSettings {
835 /// Enables or disables formatting with Prettier for a given language.
836 #[serde(default)]
837 pub allowed: bool,
838
839 /// Forces Prettier integration to use a specific parser name when formatting files with the language.
840 #[serde(default)]
841 pub parser: Option<String>,
842
843 /// Forces Prettier integration to use specific plugins when formatting files with the language.
844 /// The default Prettier will be installed with these plugins.
845 #[serde(default)]
846 pub plugins: HashSet<String>,
847
848 /// Default Prettier options, in the format as in package.json section for Prettier.
849 /// If project installs Prettier via its package.json, these options will be ignored.
850 #[serde(flatten)]
851 pub options: HashMap<String, serde_json::Value>,
852}
853
854#[cfg(test)]
855mod tests {
856 use super::*;
857
858 #[test]
859 pub fn test_resolve_language_servers() {
860 fn language_server_names(names: &[&str]) -> Vec<LanguageServerName> {
861 names
862 .into_iter()
863 .copied()
864 .map(|name| LanguageServerName(name.into()))
865 .collect::<Vec<_>>()
866 }
867
868 let available_language_servers = language_server_names(&[
869 "typescript-language-server",
870 "biome",
871 "deno",
872 "eslint",
873 "tailwind",
874 ]);
875
876 // A value of just `["..."]` is the same as taking all of the available language servers.
877 assert_eq!(
878 LanguageSettings::resolve_language_servers(
879 &[LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()],
880 &available_language_servers,
881 ),
882 available_language_servers
883 );
884
885 // Referencing one of the available language servers will change its order.
886 assert_eq!(
887 LanguageSettings::resolve_language_servers(
888 &[
889 "biome".into(),
890 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into(),
891 "deno".into()
892 ],
893 &available_language_servers
894 ),
895 language_server_names(&[
896 "biome",
897 "typescript-language-server",
898 "eslint",
899 "tailwind",
900 "deno",
901 ])
902 );
903
904 // Negating an available language server removes it from the list.
905 assert_eq!(
906 LanguageSettings::resolve_language_servers(
907 &[
908 "deno".into(),
909 "!typescript-language-server".into(),
910 "!biome".into(),
911 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()
912 ],
913 &available_language_servers
914 ),
915 language_server_names(&["deno", "eslint", "tailwind"])
916 );
917
918 // Adding a language server not in the list of available language servers adds it to the list.
919 assert_eq!(
920 LanguageSettings::resolve_language_servers(
921 &[
922 "my-cool-language-server".into(),
923 LanguageSettings::REST_OF_LANGUAGE_SERVERS.into()
924 ],
925 &available_language_servers
926 ),
927 language_server_names(&[
928 "my-cool-language-server",
929 "typescript-language-server",
930 "biome",
931 "deno",
932 "eslint",
933 "tailwind",
934 ])
935 );
936 }
937}