yulang-runtime-refine 0.1.0

Runtime type refinement, validation, invariant checks, and hygiene printing for Yulang.
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

use super::*;

impl RefineRewriter {
    pub(super) fn pattern(&mut self, pattern: Pattern) -> Pattern {
        match pattern {
            Pattern::Wildcard { ty } => Pattern::Wildcard {
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Bind { name, ty } => Pattern::Bind {
                name,
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Lit { lit, ty } => Pattern::Lit {
                lit,
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Tuple { items, ty } => Pattern::Tuple {
                items: items.into_iter().map(|item| self.pattern(item)).collect(),
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::List {
                prefix,
                spread,
                suffix,
                ty,
            } => Pattern::List {
                prefix: prefix.into_iter().map(|item| self.pattern(item)).collect(),
                spread: spread.map(|spread| Box::new(self.pattern(*spread))),
                suffix: suffix.into_iter().map(|item| self.pattern(item)).collect(),
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Record { fields, spread, ty } => Pattern::Record {
                fields: fields
                    .into_iter()
                    .map(|field| RecordPatternField {
                        name: field.name,
                        pattern: self.pattern(field.pattern),
                        default: field.default.map(|default| self.expr(default, None)),
                    })
                    .collect(),
                spread: spread.map(|spread| match spread {
                    RecordSpreadPattern::Head(pattern) => {
                        RecordSpreadPattern::Head(Box::new(self.pattern(*pattern)))
                    }
                    RecordSpreadPattern::Tail(pattern) => {
                        RecordSpreadPattern::Tail(Box::new(self.pattern(*pattern)))
                    }
                }),
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Variant { tag, value, ty } => Pattern::Variant {
                tag,
                value: value.map(|value| Box::new(self.pattern(*value))),
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::Or { left, right, ty } => Pattern::Or {
                left: Box::new(self.pattern(*left)),
                right: Box::new(self.pattern(*right)),
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
            Pattern::As { pattern, name, ty } => Pattern::As {
                pattern: Box::new(self.pattern(*pattern)),
                name,
                ty: substitute_hir_type(&ty, &self.substitutions),
            },
        }
    }
}