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.enabled {
176 return kinds;
177 }
178 if self.show_type_hints {
179 kinds.insert(Some(InlayHintKind::Type));
180 }
181 if self.show_parameter_hints {
182 kinds.insert(Some(InlayHintKind::Parameter));
183 }
184 if self.show_other_hints {
185 kinds.insert(None);
186 }
187 kinds
188 }
189}
190
191impl AllLanguageSettings {
192 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
193 if let Some(name) = language_name {
194 if let Some(overrides) = self.languages.get(name) {
195 return overrides;
196 }
197 }
198 &self.defaults
199 }
200
201 pub fn copilot_enabled_for_path(&self, path: &Path) -> bool {
202 !self
203 .copilot
204 .disabled_globs
205 .iter()
206 .any(|glob| glob.is_match(path))
207 }
208
209 pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
210 if !self.copilot.feature_enabled {
211 return false;
212 }
213
214 if let Some(path) = path {
215 if !self.copilot_enabled_for_path(path) {
216 return false;
217 }
218 }
219
220 self.language(language.map(|l| l.name()).as_deref())
221 .show_copilot_suggestions
222 }
223}
224
225#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
226pub enum InlayHintKind {
227 Type,
228 Parameter,
229}
230
231impl InlayHintKind {
232 pub fn from_name(name: &str) -> Option<Self> {
233 match name {
234 "type" => Some(InlayHintKind::Type),
235 "parameter" => Some(InlayHintKind::Parameter),
236 _ => None,
237 }
238 }
239
240 pub fn name(&self) -> &'static str {
241 match self {
242 InlayHintKind::Type => "type",
243 InlayHintKind::Parameter => "parameter",
244 }
245 }
246}
247
248impl settings::Setting for AllLanguageSettings {
249 const KEY: Option<&'static str> = None;
250
251 type FileContent = AllLanguageSettingsContent;
252
253 fn load(
254 default_value: &Self::FileContent,
255 user_settings: &[&Self::FileContent],
256 _: &AppContext,
257 ) -> Result<Self> {
258 // A default is provided for all settings.
259 let mut defaults: LanguageSettings =
260 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
261
262 let mut languages = HashMap::default();
263 for (language_name, settings) in &default_value.languages {
264 let mut language_settings = defaults.clone();
265 merge_settings(&mut language_settings, &settings);
266 languages.insert(language_name.clone(), language_settings);
267 }
268
269 let mut copilot_enabled = default_value
270 .features
271 .as_ref()
272 .and_then(|f| f.copilot)
273 .ok_or_else(Self::missing_default)?;
274 let mut copilot_globs = default_value
275 .copilot
276 .as_ref()
277 .and_then(|c| c.disabled_globs.as_ref())
278 .ok_or_else(Self::missing_default)?;
279
280 for user_settings in user_settings {
281 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
282 copilot_enabled = copilot;
283 }
284 if let Some(globs) = user_settings
285 .copilot
286 .as_ref()
287 .and_then(|f| f.disabled_globs.as_ref())
288 {
289 copilot_globs = globs;
290 }
291
292 // A user's global settings override the default global settings and
293 // all default language-specific settings.
294 merge_settings(&mut defaults, &user_settings.defaults);
295 for language_settings in languages.values_mut() {
296 merge_settings(language_settings, &user_settings.defaults);
297 }
298
299 // A user's language-specific settings override default language-specific settings.
300 for (language_name, user_language_settings) in &user_settings.languages {
301 merge_settings(
302 languages
303 .entry(language_name.clone())
304 .or_insert_with(|| defaults.clone()),
305 &user_language_settings,
306 );
307 }
308 }
309
310 Ok(Self {
311 copilot: CopilotSettings {
312 feature_enabled: copilot_enabled,
313 disabled_globs: copilot_globs
314 .iter()
315 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
316 .collect(),
317 },
318 defaults,
319 languages,
320 })
321 }
322
323 fn json_schema(
324 generator: &mut schemars::gen::SchemaGenerator,
325 params: &settings::SettingsJsonSchemaParams,
326 _: &AppContext,
327 ) -> schemars::schema::RootSchema {
328 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
329
330 // Create a schema for a 'languages overrides' object, associating editor
331 // settings with specific languages.
332 assert!(root_schema
333 .definitions
334 .contains_key("LanguageSettingsContent"));
335
336 let languages_object_schema = SchemaObject {
337 instance_type: Some(InstanceType::Object.into()),
338 object: Some(Box::new(ObjectValidation {
339 properties: params
340 .language_names
341 .iter()
342 .map(|name| {
343 (
344 name.clone(),
345 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
346 )
347 })
348 .collect(),
349 ..Default::default()
350 })),
351 ..Default::default()
352 };
353
354 root_schema
355 .definitions
356 .extend([("Languages".into(), languages_object_schema.into())]);
357
358 root_schema
359 .schema
360 .object
361 .as_mut()
362 .unwrap()
363 .properties
364 .extend([
365 (
366 "languages".to_owned(),
367 Schema::new_ref("#/definitions/Languages".into()),
368 ),
369 // For backward compatibility
370 (
371 "language_overrides".to_owned(),
372 Schema::new_ref("#/definitions/Languages".into()),
373 ),
374 ]);
375
376 root_schema
377 }
378}
379
380fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
381 merge(&mut settings.tab_size, src.tab_size);
382 merge(&mut settings.hard_tabs, src.hard_tabs);
383 merge(&mut settings.soft_wrap, src.soft_wrap);
384 merge(
385 &mut settings.preferred_line_length,
386 src.preferred_line_length,
387 );
388 merge(&mut settings.formatter, src.formatter.clone());
389 merge(&mut settings.format_on_save, src.format_on_save.clone());
390 merge(
391 &mut settings.remove_trailing_whitespace_on_save,
392 src.remove_trailing_whitespace_on_save,
393 );
394 merge(
395 &mut settings.ensure_final_newline_on_save,
396 src.ensure_final_newline_on_save,
397 );
398 merge(
399 &mut settings.enable_language_server,
400 src.enable_language_server,
401 );
402 merge(
403 &mut settings.show_copilot_suggestions,
404 src.show_copilot_suggestions,
405 );
406 merge(&mut settings.show_whitespaces, src.show_whitespaces);
407 merge(
408 &mut settings.extend_comment_on_newline,
409 src.extend_comment_on_newline,
410 );
411 merge(&mut settings.inlay_hints, src.inlay_hints);
412 fn merge<T>(target: &mut T, value: Option<T>) {
413 if let Some(value) = value {
414 *target = value;
415 }
416 }
417}