[rustc.git] / src / tools / rustfmt / src / config / config_type.rs

use crate::config::file_lines::FileLines;
use crate::config::options::{IgnoreList, WidthHeuristics};

/// Trait for types that can be used in `Config`.
pub(crate) trait ConfigType: Sized {
    /// Returns hint text for use in `Config::print_docs()`. For enum types, this is a
    /// pipe-separated list of variants; for other types it returns "<type>".
    fn doc_hint() -> String;
}

impl ConfigType for bool {
    fn doc_hint() -> String {
        String::from("<boolean>")
    }
}

impl ConfigType for usize {
    fn doc_hint() -> String {
        String::from("<unsigned integer>")
    }
}

impl ConfigType for isize {
    fn doc_hint() -> String {
        String::from("<signed integer>")
    }
}

impl ConfigType for String {
    fn doc_hint() -> String {
        String::from("<string>")
    }
}

impl ConfigType for FileLines {
    fn doc_hint() -> String {
        String::from("<json>")
    }
}

impl ConfigType for WidthHeuristics {
    fn doc_hint() -> String {
        String::new()
    }
}

impl ConfigType for IgnoreList {
    fn doc_hint() -> String {
        String::from("[<string>,..]")
    }
}

macro_rules! create_config {
    ($($i:ident: $ty:ty, $def:expr, $stb:expr, $( $dstring:expr ),+ );+ $(;)*) => (
        #[cfg(test)]
        use std::collections::HashSet;
        use std::io::Write;

        use serde::{Deserialize, Serialize};

        #[derive(Clone)]
        #[allow(unreachable_pub)]
        pub struct Config {
            // if a license_template_path has been specified, successfully read, parsed and compiled
            // into a regex, it will be stored here
            pub license_template: Option<Regex>,
            // For each config item, we store a bool indicating whether it has
            // been accessed and the value, and a bool whether the option was
            // manually initialised, or taken from the default,
            $($i: (Cell<bool>, bool, $ty, bool)),+
        }

        // Just like the Config struct but with each property wrapped
        // as Option<T>. This is used to parse a rustfmt.toml that doesn't
        // specify all properties of `Config`.
        // We first parse into `PartialConfig`, then create a default `Config`
        // and overwrite the properties with corresponding values from `PartialConfig`.
        #[derive(Deserialize, Serialize, Clone)]
        #[allow(unreachable_pub)]
        pub struct PartialConfig {
            $(pub $i: Option<$ty>),+
        }

        // Macro hygiene won't allow us to make `set_$i()` methods on Config
        // for each item, so this struct is used to give the API to set values:
        // `config.set().option(false)`. It's pretty ugly. Consider replacing
        // with `config.set_option(false)` if we ever get a stable/usable
        // `concat_idents!()`.
        #[allow(unreachable_pub)]
        pub struct ConfigSetter<'a>(&'a mut Config);

        impl<'a> ConfigSetter<'a> {
            $(
            #[allow(unreachable_pub)]
            pub fn $i(&mut self, value: $ty) {
                (self.0).$i.2 = value;
                match stringify!($i) {
                    "max_width" | "use_small_heuristics" => self.0.set_heuristics(),
                    "license_template_path" => self.0.set_license_template(),
                    "merge_imports" => self.0.set_merge_imports(),
                    &_ => (),
                }
            }
            )+
        }

        // Query each option, returns true if the user set the option, false if
        // a default was used.
        #[allow(unreachable_pub)]
        pub struct ConfigWasSet<'a>(&'a Config);

        impl<'a> ConfigWasSet<'a> {
            $(
            #[allow(unreachable_pub)]
            pub fn $i(&self) -> bool {
                (self.0).$i.1
            }
            )+
        }

        impl Config {
            $(
            #[allow(unreachable_pub)]
            pub fn $i(&self) -> $ty {
                self.$i.0.set(true);
                self.$i.2.clone()
            }
            )+

            #[allow(unreachable_pub)]
            pub fn set(&mut self) -> ConfigSetter<'_> {
                ConfigSetter(self)
            }

            #[allow(unreachable_pub)]
            pub fn was_set(&self) -> ConfigWasSet<'_> {
                ConfigWasSet(self)
            }

            fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
            $(
                if let Some(val) = parsed.$i {
                    if self.$i.3 {
                        self.$i.1 = true;
                        self.$i.2 = val;
                    } else {
                        if crate::is_nightly_channel!() {
                            self.$i.1 = true;
                            self.$i.2 = val;
                        } else {
                            eprintln!("Warning: can't set `{} = {:?}`, unstable features are only \
                                       available in nightly channel.", stringify!($i), val);
                        }
                    }
                }
            )+
                self.set_heuristics();
                self.set_license_template();
                self.set_ignore(dir);
                self.set_merge_imports();
                self
            }

            /// Returns a hash set initialized with every user-facing config option name.
            #[cfg(test)]
            pub(crate) fn hash_set() -> HashSet<String> {
                let mut hash_set = HashSet::new();
                $(
                    hash_set.insert(stringify!($i).to_owned());
                )+
                hash_set
            }

            pub(crate) fn is_valid_name(name: &str) -> bool {
                match name {
                    $(
                        stringify!($i) => true,
                    )+
                        _ => false,
                }
            }

            #[allow(unreachable_pub)]
            pub fn is_valid_key_val(key: &str, val: &str) -> bool {
                match key {
                    $(
                        stringify!($i) => val.parse::<$ty>().is_ok(),
                    )+
                        _ => false,
                }
            }

            #[allow(unreachable_pub)]
            pub fn used_options(&self) -> PartialConfig {
                PartialConfig {
                    $(
                        $i: if self.$i.0.get() {
                                Some(self.$i.2.clone())
                            } else {
                                None
                            },
                    )+
                }
            }

            #[allow(unreachable_pub)]
            pub fn all_options(&self) -> PartialConfig {
                PartialConfig {
                    $(
                        $i: Some(self.$i.2.clone()),
                    )+
                }
            }

            #[allow(unreachable_pub)]
            pub fn override_value(&mut self, key: &str, val: &str)
            {
                match key {
                    $(
                        stringify!($i) => {
                            self.$i.1 = true;
                            self.$i.2 = val.parse::<$ty>()
                                .expect(&format!("Failed to parse override for {} (\"{}\") as a {}",
                                                 stringify!($i),
                                                 val,
                                                 stringify!($ty)));
                        }
                    )+
                    _ => panic!("Unknown config key in override: {}", key)
                }

                match key {
                    "max_width" | "use_small_heuristics" => self.set_heuristics(),
                    "license_template_path" => self.set_license_template(),
                    "merge_imports" => self.set_merge_imports(),
                    &_ => (),
                }
            }

            #[allow(unreachable_pub)]
            pub fn is_hidden_option(name: &str) -> bool {
                const HIDE_OPTIONS: [&str; 5] =
                    ["verbose", "verbose_diff", "file_lines", "width_heuristics", "merge_imports"];
                HIDE_OPTIONS.contains(&name)
            }

            #[allow(unreachable_pub)]
            pub fn print_docs(out: &mut dyn Write, include_unstable: bool) {
                use std::cmp;
                let max = 0;
                $( let max = cmp::max(max, stringify!($i).len()+1); )+
                let space_str = " ".repeat(max);
                writeln!(out, "Configuration Options:").unwrap();
                $(
                    if $stb || include_unstable {
                        let name_raw = stringify!($i);

                        if !Config::is_hidden_option(name_raw) {
                            let mut name_out = String::with_capacity(max);
                            for _ in name_raw.len()..max-1 {
                                name_out.push(' ')
                            }
                            name_out.push_str(name_raw);
                            name_out.push(' ');
                            let mut default_str = format!("{}", $def);
                            if default_str.is_empty() {
                                default_str = String::from("\"\"");
                            }
                            writeln!(out,
                                    "{}{} Default: {}{}",
                                    name_out,
                                    <$ty>::doc_hint(),
                                    default_str,
                                    if !$stb { " (unstable)" } else { "" }).unwrap();
                            $(
                                writeln!(out, "{}{}", space_str, $dstring).unwrap();
                            )+
                            writeln!(out).unwrap();
                        }
                    }
                )+
            }

            fn set_heuristics(&mut self) {
                if self.use_small_heuristics.2 == Heuristics::Default {
                    let max_width = self.max_width.2;
                    self.set().width_heuristics(WidthHeuristics::scaled(max_width));
                } else if self.use_small_heuristics.2 == Heuristics::Max {
                    let max_width = self.max_width.2;
                    self.set().width_heuristics(WidthHeuristics::set(max_width));
                } else {
                    self.set().width_heuristics(WidthHeuristics::null());
                }
            }

            fn set_license_template(&mut self) {
                if self.was_set().license_template_path() {
                    let lt_path = self.license_template_path();
                    if lt_path.len() > 0 {
                        match license::load_and_compile_template(&lt_path) {
                            Ok(re) => self.license_template = Some(re),
                            Err(msg) => eprintln!("Warning for license template file {:?}: {}",
                                                lt_path, msg),
                        }
                    } else {
                        self.license_template = None;
                    }
                }
            }

            fn set_ignore(&mut self, dir: &Path) {
                self.ignore.2.add_prefix(dir);
            }

            fn set_merge_imports(&mut self) {
                if self.was_set().merge_imports() {
                    eprintln!(
                        "Warning: the `merge_imports` option is deprecated. \
                        Use `imports_granularity=Crate` instead"
                    );
                    if !self.was_set().imports_granularity() {
                        self.imports_granularity.2 = if self.merge_imports() {
                            ImportGranularity::Crate
                        } else {
                            ImportGranularity::Preserve
                        };
                    }
                }
            }

            #[allow(unreachable_pub)]
            /// Returns `true` if the config key was explicitly set and is the default value.
            pub fn is_default(&self, key: &str) -> bool {
                $(
                    if let stringify!($i) = key {
                        return self.$i.1 && self.$i.2 == $def;
                    }
                 )+
                false
            }
        }

        // Template for the default configuration
        impl Default for Config {
            fn default() -> Config {
                Config {
                    license_template: None,
                    $(
                        $i: (Cell::new(false), false, $def, $stb),
                    )+
                }
            }
        }
    )
}
Commit	Line	Data
f20569fa XL	1	use crate::config::file_lines::FileLines;
	2	use crate::config::options::{IgnoreList, WidthHeuristics};
	3
	4	/// Trait for types that can be used in `Config`.
	5	pub(crate) trait ConfigType: Sized {
	6	/// Returns hint text for use in `Config::print_docs()`. For enum types, this is a
	7	/// pipe-separated list of variants; for other types it returns "<type>".
	8	fn doc_hint() -> String;
	9	}
	10
	11	impl ConfigType for bool {
	12	fn doc_hint() -> String {
	13	String::from("<boolean>")
	14	}
	15	}
	16
	17	impl ConfigType for usize {
	18	fn doc_hint() -> String {
	19	String::from("<unsigned integer>")
	20	}
	21	}
	22
	23	impl ConfigType for isize {
	24	fn doc_hint() -> String {
	25	String::from("<signed integer>")
	26	}
	27	}
	28
	29	impl ConfigType for String {
	30	fn doc_hint() -> String {
	31	String::from("<string>")
	32	}
	33	}
	34
	35	impl ConfigType for FileLines {
	36	fn doc_hint() -> String {
	37	String::from("<json>")
	38	}
	39	}
	40
	41	impl ConfigType for WidthHeuristics {
	42	fn doc_hint() -> String {
	43	String::new()
	44	}
	45	}
	46
	47	impl ConfigType for IgnoreList {
	48	fn doc_hint() -> String {
	49	String::from("[<string>,..]")
	50	}
	51	}
	52
	53	macro_rules! create_config {
	54	($($i:ident: $ty:ty, $def:expr, $stb:expr, $( $dstring:expr ),+ );+ $(;)*) => (
	55	#[cfg(test)]
	56	use std::collections::HashSet;
	57	use std::io::Write;
	58
	59	use serde::{Deserialize, Serialize};
	60
	61	#[derive(Clone)]
	62	#[allow(unreachable_pub)]
	63	pub struct Config {
	64	// if a license_template_path has been specified, successfully read, parsed and compiled
65	// into a regex, it will be stored here
66	pub license_template: Option<Regex>,
67	// For each config item, we store a bool indicating whether it has
68	// been accessed and the value, and a bool whether the option was
69	// manually initialised, or taken from the default,
70	$($i: (Cell<bool>, bool, $ty, bool)),+
71	}
72
73	// Just like the Config struct but with each property wrapped
74	// as Option<T>. This is used to parse a rustfmt.toml that doesn't
75	// specify all properties of `Config`.
76	// We first parse into `PartialConfig`, then create a default `Config`
77	// and overwrite the properties with corresponding values from `PartialConfig`.
78	#[derive(Deserialize, Serialize, Clone)]
79	#[allow(unreachable_pub)]
80	pub struct PartialConfig {
81	$(pub $i: Option<$ty>),+
82	}
83
84	// Macro hygiene won't allow us to make `set_$i()` methods on Config
85	// for each item, so this struct is used to give the API to set values:
86	// `config.set().option(false)`. It's pretty ugly. Consider replacing
87	// with `config.set_option(false)` if we ever get a stable/usable
88	// `concat_idents!()`.
89	#[allow(unreachable_pub)]
90	pub struct ConfigSetter<'a>(&'a mut Config);
91
92	impl<'a> ConfigSetter<'a> {
93	$(
94	#[allow(unreachable_pub)]
95	pub fn $i(&mut self, value: $ty) {
96	(self.0).$i.2 = value;
97	match stringify!($i) {
98	"max_width" \| "use_small_heuristics" => self.0.set_heuristics(),
99	"license_template_path" => self.0.set_license_template(),
100	"merge_imports" => self.0.set_merge_imports(),
101	&_ => (),
102	}
103	}
104	)+
105	}
106
107	// Query each option, returns true if the user set the option, false if
108	// a default was used.
109	#[allow(unreachable_pub)]
110	pub struct ConfigWasSet<'a>(&'a Config);
111
112	impl<'a> ConfigWasSet<'a> {
113	$(
114	#[allow(unreachable_pub)]
115	pub fn $i(&self) -> bool {
116	(self.0).$i.1
117	}
118	)+
119	}
120
121	impl Config {
122	$(
123	#[allow(unreachable_pub)]
124	pub fn $i(&self) -> $ty {
125	self.$i.0.set(true);
126	self.$i.2.clone()
127	}
128	)+
129
130	#[allow(unreachable_pub)]
131	pub fn set(&mut self) -> ConfigSetter<'_> {
132	ConfigSetter(self)
133	}
134
135	#[allow(unreachable_pub)]
136	pub fn was_set(&self) -> ConfigWasSet<'_> {
137	ConfigWasSet(self)
138	}
139
140	fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
141	$(
142	if let Some(val) = parsed.$i {
143	if self.$i.3 {
144	self.$i.1 = true;
145	self.$i.2 = val;
146	} else {
147	if crate::is_nightly_channel!() {
148	self.$i.1 = true;
149	self.$i.2 = val;
150	} else {
151	eprintln!("Warning: can't set `{} = {:?}`, unstable features are only \
152	available in nightly channel.", stringify!($i), val);
153	}
154	}
155	}
156	)+
157	self.set_heuristics();
158	self.set_license_template();
159	self.set_ignore(dir);
160	self.set_merge_imports();
161	self
162	}
163
164	/// Returns a hash set initialized with every user-facing config option name.
165	#[cfg(test)]
166	pub(crate) fn hash_set() -> HashSet<String> {
167	let mut hash_set = HashSet::new();
168	$(
169	hash_set.insert(stringify!($i).to_owned());
170	)+
171	hash_set
172	}
173
174	pub(crate) fn is_valid_name(name: &str) -> bool {
175	match name {
176	$(
177	stringify!($i) => true,
178	)+
179	_ => false,
180	}
181	}
182
183	#[allow(unreachable_pub)]
184	pub fn is_valid_key_val(key: &str, val: &str) -> bool {
185	match key {
186	$(
187	stringify!($i) => val.parse::<$ty>().is_ok(),
188	)+
189	_ => false,
190	}
191	}
192
193	#[allow(unreachable_pub)]
194	pub fn used_options(&self) -> PartialConfig {
195	PartialConfig {
196	$(
197	$i: if self.$i.0.get() {
198	Some(self.$i.2.clone())
199	} else {
200	None
201	},
202	)+
203	}
204	}
205
206	#[allow(unreachable_pub)]
207	pub fn all_options(&self) -> PartialConfig {
208	PartialConfig {
209	$(
210	$i: Some(self.$i.2.clone()),
211	)+
212	}
213	}
214
215	#[allow(unreachable_pub)]
216	pub fn override_value(&mut self, key: &str, val: &str)
217	{
218	match key {
219	$(
220	stringify!($i) => {
221	self.$i.1 = true;
222	self.$i.2 = val.parse::<$ty>()
223	.expect(&format!("Failed to parse override for {} (\"{}\") as a {}",
224	stringify!($i),
225	val,
226	stringify!($ty)));
227	}
228	)+
229	_ => panic!("Unknown config key in override: {}", key)
230	}
231
232	match key {
233	"max_width" \| "use_small_heuristics" => self.set_heuristics(),
234	"license_template_path" => self.set_license_template(),
235	"merge_imports" => self.set_merge_imports(),
236	&_ => (),
237	}
238	}
239
240	#[allow(unreachable_pub)]
241	pub fn is_hidden_option(name: &str) -> bool {
242	const HIDE_OPTIONS: [&str; 5] =
243	["verbose", "verbose_diff", "file_lines", "width_heuristics", "merge_imports"];
244	HIDE_OPTIONS.contains(&name)
245	}
246
247	#[allow(unreachable_pub)]
248	pub fn print_docs(out: &mut dyn Write, include_unstable: bool) {
249	use std::cmp;
250	let max = 0;
251	$( let max = cmp::max(max, stringify!($i).len()+1); )+
252	let space_str = " ".repeat(max);
253	writeln!(out, "Configuration Options:").unwrap();
254	$(
255	if $stb \|\| include_unstable {
256	let name_raw = stringify!($i);
257
258	if !Config::is_hidden_option(name_raw) {
259	let mut name_out = String::with_capacity(max);
260	for _ in name_raw.len()..max-1 {
261	name_out.push(' ')
262	}
263	name_out.push_str(name_raw);
264	name_out.push(' ');
265	let mut default_str = format!("{}", $def);
266	if default_str.is_empty() {
267	default_str = String::from("\"\"");
268	}
269	writeln!(out,
270	"{}{} Default: {}{}",
271	name_out,
272	<$ty>::doc_hint(),
273	default_str,
274	if !$stb { " (unstable)" } else { "" }).unwrap();
275	$(
276	writeln!(out, "{}{}", space_str, $dstring).unwrap();
277	)+
278	writeln!(out).unwrap();
279	}
280	}
281	)+
282	}
283
284	fn set_heuristics(&mut self) {
285	if self.use_small_heuristics.2 == Heuristics::Default {
286	let max_width = self.max_width.2;
287	self.set().width_heuristics(WidthHeuristics::scaled(max_width));
288	} else if self.use_small_heuristics.2 == Heuristics::Max {
289	let max_width = self.max_width.2;
290	self.set().width_heuristics(WidthHeuristics::set(max_width));
291	} else {
292	self.set().width_heuristics(WidthHeuristics::null());
293	}
294	}
295
296	fn set_license_template(&mut self) {
297	if self.was_set().license_template_path() {
298	let lt_path = self.license_template_path();
299	if lt_path.len() > 0 {
300	match license::load_and_compile_template(&lt_path) {
301	Ok(re) => self.license_template = Some(re),
302	Err(msg) => eprintln!("Warning for license template file {:?}: {}",
303	lt_path, msg),
304	}
305	} else {
306	self.license_template = None;
307	}
308	}
309	}
310
311	fn set_ignore(&mut self, dir: &Path) {
312	self.ignore.2.add_prefix(dir);
313	}
314
315	fn set_merge_imports(&mut self) {
316	if self.was_set().merge_imports() {
317	eprintln!(
318	"Warning: the `merge_imports` option is deprecated. \
319	Use `imports_granularity=Crate` instead"
320	);
321	if !self.was_set().imports_granularity() {
322	self.imports_granularity.2 = if self.merge_imports() {
323	ImportGranularity::Crate
324	} else {
325	ImportGranularity::Preserve
326	};
327	}
328	}
329	}
330
331	#[allow(unreachable_pub)]
332	/// Returns `true` if the config key was explicitly set and is the default value.
333	pub fn is_default(&self, key: &str) -> bool {
334	$(
335	if let stringify!($i) = key {
336	return self.$i.1 && self.$i.2 == $def;
337	}
338	)+
339	false
340	}
341	}
342
343	// Template for the default configuration
344	impl Default for Config {
345	fn default() -> Config {
346	Config {
347	license_template: None,
348	$(
349	$i: (Cell::new(false), false, $def, $stb),
350	)+
351	}
352	}
353	}
354	)
355	}