1use crate::{File, Language};
2use anyhow::Result;
3use collections::{HashMap, HashSet};
4use globset::GlobMatcher;
5use gpui::AppContext;
6use schemars::{
7 schema::{InstanceType, ObjectValidation, Schema, SchemaObject},
8 JsonSchema,
9};
10use serde::{Deserialize, Serialize};
11use std::{num::NonZeroU32, path::Path, sync::Arc};
12
13pub fn init(cx: &mut AppContext) {
14 settings::register::<AllLanguageSettings>(cx);
15}
16
17pub fn language_settings<'a>(
18 language: Option<&Arc<Language>>,
19 file: Option<&Arc<dyn File>>,
20 cx: &'a AppContext,
21) -> &'a LanguageSettings {
22 let language_name = language.map(|l| l.name());
23 all_language_settings(file, cx).language(language_name.as_deref())
24}
25
26pub fn all_language_settings<'a>(
27 file: Option<&Arc<dyn File>>,
28 cx: &'a AppContext,
29) -> &'a AllLanguageSettings {
30 let location = file.map(|f| (f.worktree_id(), f.path().as_ref()));
31 settings::get_local(location, cx)
32}
33
34#[derive(Debug, Clone)]
35pub struct AllLanguageSettings {
36 pub copilot: CopilotSettings,
37 defaults: LanguageSettings,
38 languages: HashMap<Arc<str>, LanguageSettings>,
39}
40
41#[derive(Debug, Clone, Deserialize)]
42pub struct LanguageSettings {
43 pub tab_size: NonZeroU32,
44 pub hard_tabs: bool,
45 pub soft_wrap: SoftWrap,
46 pub preferred_line_length: u32,
47 pub format_on_save: FormatOnSave,
48 pub remove_trailing_whitespace_on_save: bool,
49 pub ensure_final_newline_on_save: bool,
50 pub formatter: Formatter,
51 pub enable_language_server: bool,
52 pub show_copilot_suggestions: bool,
53 pub show_whitespaces: ShowWhitespaceSetting,
54 pub extend_comment_on_newline: bool,
55 pub inlay_hints: InlayHintSettings,
56}
57
58#[derive(Clone, Debug, Default)]
59pub struct CopilotSettings {
60 pub feature_enabled: bool,
61 pub disabled_globs: Vec<GlobMatcher>,
62}
63
64#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
65pub struct AllLanguageSettingsContent {
66 #[serde(default)]
67 pub features: Option<FeaturesContent>,
68 #[serde(default)]
69 pub copilot: Option<CopilotSettingsContent>,
70 #[serde(flatten)]
71 pub defaults: LanguageSettingsContent,
72 #[serde(default, alias = "language_overrides")]
73 pub languages: HashMap<Arc<str>, LanguageSettingsContent>,
74}
75
76#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
77pub struct LanguageSettingsContent {
78 #[serde(default)]
79 pub tab_size: Option<NonZeroU32>,
80 #[serde(default)]
81 pub hard_tabs: Option<bool>,
82 #[serde(default)]
83 pub soft_wrap: Option<SoftWrap>,
84 #[serde(default)]
85 pub preferred_line_length: Option<u32>,
86 #[serde(default)]
87 pub format_on_save: Option<FormatOnSave>,
88 #[serde(default)]
89 pub remove_trailing_whitespace_on_save: Option<bool>,
90 #[serde(default)]
91 pub ensure_final_newline_on_save: Option<bool>,
92 #[serde(default)]
93 pub formatter: Option<Formatter>,
94 #[serde(default)]
95 pub enable_language_server: Option<bool>,
96 #[serde(default)]
97 pub show_copilot_suggestions: Option<bool>,
98 #[serde(default)]
99 pub show_whitespaces: Option<ShowWhitespaceSetting>,
100 #[serde(default)]
101 pub extend_comment_on_newline: Option<bool>,
102 #[serde(default)]
103 pub inlay_hints: Option<InlayHintSettings>,
104}
105
106#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
107pub struct CopilotSettingsContent {
108 #[serde(default)]
109 pub disabled_globs: Option<Vec<String>>,
110}
111
112#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
113#[serde(rename_all = "snake_case")]
114pub struct FeaturesContent {
115 pub copilot: Option<bool>,
116}
117
118#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
119#[serde(rename_all = "snake_case")]
120pub enum SoftWrap {
121 None,
122 EditorWidth,
123 PreferredLineLength,
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
127#[serde(rename_all = "snake_case")]
128pub enum FormatOnSave {
129 On,
130 Off,
131 LanguageServer,
132 External {
133 command: Arc<str>,
134 arguments: Arc<[String]>,
135 },
136}
137
138#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
139#[serde(rename_all = "snake_case")]
140pub enum ShowWhitespaceSetting {
141 Selection,
142 None,
143 All,
144}
145
146#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
147#[serde(rename_all = "snake_case")]
148pub enum Formatter {
149 LanguageServer,
150 External {
151 command: Arc<str>,
152 arguments: Arc<[String]>,
153 },
154}
155
156#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
157pub struct InlayHintSettings {
158 #[serde(default)]
159 pub enabled: bool,
160 #[serde(default = "default_true")]
161 pub show_type_hints: bool,
162 #[serde(default = "default_true")]
163 pub show_parameter_hints: bool,
164 #[serde(default = "default_true")]
165 pub show_other_hints: bool,
166}
167
168fn default_true() -> bool {
169 true
170}
171
172impl InlayHintSettings {
173 pub fn enabled_inlay_hint_kinds(&self) -> HashSet<Option<InlayHintKind>> {
174 let mut kinds = HashSet::default();
175 if self.show_type_hints {
176 kinds.insert(Some(InlayHintKind::Type));
177 }
178 if self.show_parameter_hints {
179 kinds.insert(Some(InlayHintKind::Parameter));
180 }
181 if self.show_other_hints {
182 kinds.insert(None);
183 }
184 kinds
185 }
186}
187
188impl AllLanguageSettings {
189 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
190 if let Some(name) = language_name {
191 if let Some(overrides) = self.languages.get(name) {
192 return overrides;
193 }
194 }
195 &self.defaults
196 }
197
198 pub fn copilot_enabled_for_path(&self, path: &Path) -> bool {
199 !self
200 .copilot
201 .disabled_globs
202 .iter()
203 .any(|glob| glob.is_match(path))
204 }
205
206 pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
207 if !self.copilot.feature_enabled {
208 return false;
209 }
210
211 if let Some(path) = path {
212 if !self.copilot_enabled_for_path(path) {
213 return false;
214 }
215 }
216
217 self.language(language.map(|l| l.name()).as_deref())
218 .show_copilot_suggestions
219 }
220}
221
222#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
223pub enum InlayHintKind {
224 Type,
225 Parameter,
226}
227
228impl InlayHintKind {
229 pub fn from_name(name: &str) -> Option<Self> {
230 match name {
231 "type" => Some(InlayHintKind::Type),
232 "parameter" => Some(InlayHintKind::Parameter),
233 _ => None,
234 }
235 }
236
237 pub fn name(&self) -> &'static str {
238 match self {
239 InlayHintKind::Type => "type",
240 InlayHintKind::Parameter => "parameter",
241 }
242 }
243}
244
245impl settings::Setting for AllLanguageSettings {
246 const KEY: Option<&'static str> = None;
247
248 type FileContent = AllLanguageSettingsContent;
249
250 fn load(
251 default_value: &Self::FileContent,
252 user_settings: &[&Self::FileContent],
253 _: &AppContext,
254 ) -> Result<Self> {
255 // A default is provided for all settings.
256 let mut defaults: LanguageSettings =
257 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
258
259 let mut languages = HashMap::default();
260 for (language_name, settings) in &default_value.languages {
261 let mut language_settings = defaults.clone();
262 merge_settings(&mut language_settings, &settings);
263 languages.insert(language_name.clone(), language_settings);
264 }
265
266 let mut copilot_enabled = default_value
267 .features
268 .as_ref()
269 .and_then(|f| f.copilot)
270 .ok_or_else(Self::missing_default)?;
271 let mut copilot_globs = default_value
272 .copilot
273 .as_ref()
274 .and_then(|c| c.disabled_globs.as_ref())
275 .ok_or_else(Self::missing_default)?;
276
277 for user_settings in user_settings {
278 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
279 copilot_enabled = copilot;
280 }
281 if let Some(globs) = user_settings
282 .copilot
283 .as_ref()
284 .and_then(|f| f.disabled_globs.as_ref())
285 {
286 copilot_globs = globs;
287 }
288
289 // A user's global settings override the default global settings and
290 // all default language-specific settings.
291 merge_settings(&mut defaults, &user_settings.defaults);
292 for language_settings in languages.values_mut() {
293 merge_settings(language_settings, &user_settings.defaults);
294 }
295
296 // A user's language-specific settings override default language-specific settings.
297 for (language_name, user_language_settings) in &user_settings.languages {
298 merge_settings(
299 languages
300 .entry(language_name.clone())
301 .or_insert_with(|| defaults.clone()),
302 &user_language_settings,
303 );
304 }
305 }
306
307 Ok(Self {
308 copilot: CopilotSettings {
309 feature_enabled: copilot_enabled,
310 disabled_globs: copilot_globs
311 .iter()
312 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
313 .collect(),
314 },
315 defaults,
316 languages,
317 })
318 }
319
320 fn json_schema(
321 generator: &mut schemars::gen::SchemaGenerator,
322 params: &settings::SettingsJsonSchemaParams,
323 _: &AppContext,
324 ) -> schemars::schema::RootSchema {
325 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
326
327 // Create a schema for a 'languages overrides' object, associating editor
328 // settings with specific languages.
329 assert!(root_schema
330 .definitions
331 .contains_key("LanguageSettingsContent"));
332
333 let languages_object_schema = SchemaObject {
334 instance_type: Some(InstanceType::Object.into()),
335 object: Some(Box::new(ObjectValidation {
336 properties: params
337 .language_names
338 .iter()
339 .map(|name| {
340 (
341 name.clone(),
342 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
343 )
344 })
345 .collect(),
346 ..Default::default()
347 })),
348 ..Default::default()
349 };
350
351 root_schema
352 .definitions
353 .extend([("Languages".into(), languages_object_schema.into())]);
354
355 root_schema
356 .schema
357 .object
358 .as_mut()
359 .unwrap()
360 .properties
361 .extend([
362 (
363 "languages".to_owned(),
364 Schema::new_ref("#/definitions/Languages".into()),
365 ),
366 // For backward compatibility
367 (
368 "language_overrides".to_owned(),
369 Schema::new_ref("#/definitions/Languages".into()),
370 ),
371 ]);
372
373 root_schema
374 }
375}
376
377fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
378 merge(&mut settings.tab_size, src.tab_size);
379 merge(&mut settings.hard_tabs, src.hard_tabs);
380 merge(&mut settings.soft_wrap, src.soft_wrap);
381 merge(
382 &mut settings.preferred_line_length,
383 src.preferred_line_length,
384 );
385 merge(&mut settings.formatter, src.formatter.clone());
386 merge(&mut settings.format_on_save, src.format_on_save.clone());
387 merge(
388 &mut settings.remove_trailing_whitespace_on_save,
389 src.remove_trailing_whitespace_on_save,
390 );
391 merge(
392 &mut settings.ensure_final_newline_on_save,
393 src.ensure_final_newline_on_save,
394 );
395 merge(
396 &mut settings.enable_language_server,
397 src.enable_language_server,
398 );
399 merge(
400 &mut settings.show_copilot_suggestions,
401 src.show_copilot_suggestions,
402 );
403 merge(&mut settings.show_whitespaces, src.show_whitespaces);
404 merge(
405 &mut settings.extend_comment_on_newline,
406 src.extend_comment_on_newline,
407 );
408 merge(&mut settings.inlay_hints, src.inlay_hints);
409 fn merge<T>(target: &mut T, value: Option<T>) {
410 if let Some(value) = value {
411 *target = value;
412 }
413 }
414}