bacon 3.23.0

background rust compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use {
    crate::*,
    rustc_hash::FxHashSet,
    std::fmt,
};

#[derive(Default, Debug)]
pub struct Filter {
    dismissals: Vec<Dismissal>,
}

#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub enum Dismissal {
    Location(String),
    DiagType(String),
}

impl Dismissal {
    /// Return true if the item must be dismissed
    pub fn applies_to(
        &self,
        item: Item<'_>,
    ) -> bool {
        match self {
            Self::Location(v) => item.location().is_some_and(|loc| loc == v),
            Self::DiagType(v) => item.diag_type().is_some_and(|loc| loc == v),
        }
    }
    pub fn undo_action(&self) -> Action {
        match self {
            Self::Location(v) => Action::UndismissLocation(v.clone()),
            Self::DiagType(v) => Action::UndismissDiagType(v.clone()),
        }
    }
}

impl Filter {
    pub fn add(
        &mut self,
        dismissal: Dismissal,
    ) {
        if !self.dismissals.contains(&dismissal) {
            self.dismissals.push(dismissal);
        }
    }
    pub fn remove(
        &mut self,
        dismissal: &Dismissal,
    ) {
        self.dismissals.retain(|d| d != dismissal);
    }
    pub fn remove_dismissed_lines(
        &self,
        report: &mut Report,
    ) -> bool {
        let mut dismissed_item_idxs = FxHashSet::default();
        for item in Item::items_of(&report.lines) {
            for dismissal in &self.dismissals {
                if dismissal.applies_to(item) {
                    dismissed_item_idxs.insert(item.item_idx());
                    break;
                }
            }
        }
        let mut kept_lines = Vec::new();
        for line in report.lines.drain(..) {
            if dismissed_item_idxs.contains(&line.item_idx) {
                report.dismissed_lines.push(line);
            } else {
                kept_lines.push(line);
            }
        }
        report.lines = kept_lines;
        report.dismissed_items += dismissed_item_idxs.len();
        report.lines_changed();
        info!(
            "FILTERING, dismissed {} items: {:?}",
            dismissed_item_idxs.len(),
            dismissed_item_idxs
        );
        !dismissed_item_idxs.is_empty()
    }
    pub fn restore_dismissed_lines(
        &self,
        report: &mut Report,
    ) {
        if !report.dismissed_lines.is_empty() {
            report.lines.append(&mut report.dismissed_lines);
            report.lines.sort_by_key(|line| line.item_idx);
            report.dismissed_items = 0;
            report.lines_changed();
        }
    }
    pub fn undismiss_menu(&self) -> ActionMenu {
        let mut menu = ActionMenu::new();
        menu.add_action(Action::UndismissAll);
        for dismissal in &self.dismissals {
            menu.add_action(dismissal.undo_action());
        }
        menu
    }
}

impl fmt::Display for Dismissal {
    fn fmt(
        &self,
        f: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        match self {
            Self::Location(v) => write!(f, "location: {v}"),
            Self::DiagType(v) => write!(f, "diag_type: {v}"),
        }
    }
}