svelte-compiler 0.1.4

Core compiler API for the Rust Svelte toolchain
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 rustc_hash::FxHashSet;
use std::sync::Arc;

pub(crate) type Name = Arc<str>;
pub(crate) type NameSet = FxHashSet<Name>;

#[derive(Clone, Copy, Debug)]
pub(crate) struct NameMark(usize);

#[derive(Clone, Debug, Default)]
pub(crate) struct NameStack(Vec<Name>);

impl NameStack {
    pub(crate) fn as_slice(&self) -> &[Name] {
        &self.0
    }

    pub(crate) fn from_items<I>(items: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<Name>,
    {
        Self(items.into_iter().map(Into::into).collect())
    }

    pub(crate) fn mark(&self) -> NameMark {
        NameMark(self.0.len())
    }

    pub(crate) fn reset(&mut self, mark: NameMark) {
        self.0.truncate(mark.0);
    }

    pub(crate) fn with_frame<T>(
        &mut self,
        extend: impl FnOnce(&mut Self),
        visit: impl FnOnce(&mut Self) -> T,
    ) -> T {
        let mark = self.mark();
        extend(self);
        let result = visit(self);
        self.reset(mark);
        result
    }

    pub(crate) fn push(&mut self, name: Name) {
        self.0.push(name);
    }

    pub(crate) fn pop(&mut self) {
        let _ = self.0.pop();
    }

    pub(crate) fn extend<I>(&mut self, items: I)
    where
        I: IntoIterator<Item = Name>,
    {
        self.0.extend(items);
    }

    pub(crate) fn contains(&self, name: &str) -> bool {
        self.0.iter().any(|item| item.as_ref() == name)
    }
}

#[derive(Clone, Debug, Default)]
pub(crate) struct OrderedNames {
    names: Vec<Name>,
    seen: NameSet,
}

impl OrderedNames {
    pub(crate) fn as_slice(&self) -> &[Name] {
        &self.names
    }

    pub(crate) fn retain<F>(&mut self, mut keep: F)
    where
        F: FnMut(&Name) -> bool,
    {
        self.names.retain(|name| keep(name));
        self.seen = self.names.iter().cloned().collect();
    }

    pub(crate) fn into_boxed_slice(self) -> Box<[Name]> {
        self.names.into_boxed_slice()
    }

    pub(crate) fn into_parts(self) -> (Box<[Name]>, NameSet) {
        (self.names.into_boxed_slice(), self.seen)
    }
}

impl Extend<Name> for OrderedNames {
    fn extend<T>(&mut self, iter: T)
    where
        T: IntoIterator<Item = Name>,
    {
        for name in iter {
            if self.seen.insert(name.clone()) {
                self.names.push(name);
            }
        }
    }
}

impl IntoIterator for OrderedNames {
    type Item = Name;
    type IntoIter = std::vec::IntoIter<Name>;

    fn into_iter(self) -> Self::IntoIter {
        self.names.into_iter()
    }
}