pintc 0.14.0

Compiler for the Pint language
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::{error::Error, span::Span, warning::Warning};
use core::cell::RefCell;

/// A handler with which you can emit diagnostics.
#[derive(Default, Debug)]
pub struct Handler {
    /// The inner handler.
    /// This construction is used to avoid `&mut` all over the compiler.
    inner: RefCell<HandlerInner>,
}

/// Contains the actual data for `Handler`.
/// Modelled this way to afford an API using interior mutability.
#[derive(Default, Debug)]
struct HandlerInner {
    /// The sink through which errors and warnings will be emitted.
    errors: Vec<Error>,
    warnings: Vec<Warning>,
}

impl Handler {
    /// Emit the error `err`.
    pub fn emit_err(&self, err: Error) -> ErrorEmitted {
        self.inner.borrow_mut().errors.push(err);
        ErrorEmitted { _priv: () }
    }

    pub fn emit_internal_err<S: Into<String>>(&self, msg: S, span: Span) -> ErrorEmitted {
        self.emit_err(Error::Internal {
            msg: msg.into(),
            span,
        })
    }

    /// Emit the warning `warn`.
    pub fn emit_warn(&self, warning: Warning) {
        self.inner.borrow_mut().warnings.push(warning);
    }

    /// Compilation should be cancelled.
    pub fn cancel(&self) -> ErrorEmitted {
        ErrorEmitted { _priv: () }
    }

    /// Produce a `Result::Ok(value)` if the handler has no errors. Otherwise, produce
    /// `Result::Err(_)`
    pub fn result<T>(&self, value: T) -> Result<T, ErrorEmitted> {
        if self.has_errors() {
            Err(self.cancel())
        } else {
            Ok(value)
        }
    }

    pub fn has_errors(&self) -> bool {
        !self.inner.borrow().errors.is_empty()
    }

    pub fn has_warnings(&self) -> bool {
        !self.inner.borrow().warnings.is_empty()
    }

    pub fn clear(&self) {
        self.clear_errors();
        self.clear_warnings();
    }

    pub fn clear_errors(&self) {
        self.inner.borrow_mut().errors.clear();
    }

    pub fn clear_warnings(&self) {
        self.inner.borrow_mut().warnings.clear();
    }

    pub fn remove_internal(&self, always_remove: bool) {
        // Only remove the internal errors if there are other errors in the mix also. Otherwise we
        // may get a semi-false negative for .has_errors() later.
        let has_non_internals = !always_remove
            && self
                .inner
                .borrow()
                .errors
                .iter()
                .any(|err| !matches!(err, Error::Internal { .. }));

        if always_remove || has_non_internals {
            self.inner
                .borrow_mut()
                .errors
                .retain(|err| !matches!(err, Error::Internal { .. }));
        }
    }

    pub fn scope<T>(
        &self,
        f: impl FnOnce(&Handler) -> Result<T, ErrorEmitted>,
    ) -> Result<T, ErrorEmitted> {
        let scoped_handler = Handler::default();
        let closure_res = f(&scoped_handler);
        let had_errors = scoped_handler.has_errors();

        self.append(scoped_handler);

        if had_errors {
            Err(ErrorEmitted { _priv: () })
        } else {
            closure_res
        }
    }

    pub fn consume(self) -> (Vec<Error>, Vec<Warning>) {
        use super::Spanned;

        let HandlerInner {
            mut errors,
            mut warnings,
        } = self.inner.into_inner();

        let mut seen_errors = fxhash::FxHashSet::default();
        errors.retain(|err| {
            let sig = err.span().clone();
            seen_errors.insert(sig)
        });

        let mut seen_warnings = fxhash::FxHashSet::default();
        warnings.retain(|warn| {
            let sig = warn.span().clone();
            seen_warnings.insert(sig)
        });

        (errors, warnings)
    }

    pub fn append(&self, other: Handler) {
        let (errors, warnings) = other.consume();
        for warn in warnings {
            self.emit_warn(warn);
        }
        for err in errors {
            self.emit_err(err);
        }
    }
}

/// Proof that an error was emitted through a `Handler`.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct ErrorEmitted {
    _priv: (),
}