rustfmt_nightly/
skip.rs

1//! Module that contains skip related stuffs.
2
3use rustc_ast::ast;
4use rustc_ast_pretty::pprust;
5use std::collections::HashSet;
6
7/// Track which blocks of code are to be skipped when formatting.
8///
9/// You can update it by:
10///
11/// - attributes slice
12/// - manually feeding values into the underlying contexts
13///
14/// Query this context to know if you need to skip a block.
15#[derive(Default, Clone)]
16pub(crate) struct SkipContext {
17    pub(crate) macros: SkipNameContext,
18    pub(crate) attributes: SkipNameContext,
19}
20
21impl SkipContext {
22    pub(crate) fn update_with_attrs(&mut self, attrs: &[ast::Attribute]) {
23        self.macros.extend(get_skip_names("macros", attrs));
24        self.attributes.extend(get_skip_names("attributes", attrs));
25    }
26
27    pub(crate) fn update(&mut self, other: SkipContext) {
28        let SkipContext { macros, attributes } = other;
29        self.macros.update(macros);
30        self.attributes.update(attributes);
31    }
32}
33
34/// Track which names to skip.
35///
36/// Query this context with a string to know whether to skip it.
37#[derive(Clone)]
38pub(crate) enum SkipNameContext {
39    All,
40    Values(HashSet<String>),
41}
42
43impl Default for SkipNameContext {
44    fn default() -> Self {
45        Self::Values(Default::default())
46    }
47}
48
49impl Extend<String> for SkipNameContext {
50    fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T) {
51        match self {
52            Self::All => {}
53            Self::Values(values) => values.extend(iter),
54        }
55    }
56}
57
58impl SkipNameContext {
59    pub(crate) fn update(&mut self, other: Self) {
60        match (self, other) {
61            // If we're already skipping everything, nothing more can be added
62            (Self::All, _) => {}
63            // If we want to skip all, set it
64            (this, Self::All) => {
65                *this = Self::All;
66            }
67            // If we have some new values to skip, add them
68            (Self::Values(existing_values), Self::Values(new_values)) => {
69                existing_values.extend(new_values)
70            }
71        }
72    }
73
74    pub(crate) fn skip(&self, name: &str) -> bool {
75        match self {
76            Self::All => true,
77            Self::Values(values) => values.contains(name),
78        }
79    }
80
81    pub(crate) fn skip_all(&mut self) {
82        *self = Self::All;
83    }
84}
85
86static RUSTFMT: &str = "rustfmt";
87static SKIP: &str = "skip";
88
89/// Say if you're playing with `rustfmt`'s skip attribute
90pub(crate) fn is_skip_attr(segments: &[ast::PathSegment]) -> bool {
91    if segments.len() < 2 || segments[0].ident.to_string() != RUSTFMT {
92        return false;
93    }
94    match segments.len() {
95        2 => segments[1].ident.to_string() == SKIP,
96        3 => {
97            segments[1].ident.to_string() == SKIP
98                && ["macros", "attributes"]
99                    .iter()
100                    .any(|&n| n == pprust::path_segment_to_string(&segments[2]))
101        }
102        _ => false,
103    }
104}
105
106fn get_skip_names(kind: &str, attrs: &[ast::Attribute]) -> Vec<String> {
107    let mut skip_names = vec![];
108    let path = format!("{RUSTFMT}::{SKIP}::{kind}");
109    for attr in attrs {
110        // rustc_ast::ast::Path is implemented partialEq
111        // but it is designed for segments.len() == 1
112        if let ast::AttrKind::Normal(normal) = &attr.kind {
113            if pprust::path_to_string(&normal.item.path) != path {
114                continue;
115            }
116        }
117
118        if let Some(list) = attr.meta_item_list() {
119            for meta_item_inner in list {
120                if let Some(name) = meta_item_inner.ident() {
121                    skip_names.push(name.to_string());
122                }
123            }
124        }
125    }
126    skip_names
127}