pomsky 0.12.0

A new regular expression 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

use std::collections::HashMap;

use pomsky_syntax::exprs::{self, Capture, GroupKind};

use crate::{
    diagnose::{CompileError, CompileErrorKind},
    visitor::RuleVisitor,
};

#[derive(Default)]
pub(crate) struct CapturingGroupsCollector {
    pub(crate) count_named: u32,
    pub(crate) count_numbered: u32,
    pub(crate) names: HashMap<String, CapturingGroupIndex>,
    pub(crate) variable_nesting: u32,
}

#[derive(Clone)]
pub(crate) struct CapturingGroupIndex {
    pub(crate) from_named: u32,
    pub(crate) absolute: u32,
}

impl CapturingGroupsCollector {
    pub(crate) fn new() -> Self {
        CapturingGroupsCollector::default()
    }
}

impl RuleVisitor<CompileError> for CapturingGroupsCollector {
    fn down(&mut self, kind: crate::visitor::NestingKind) {
        if let crate::visitor::NestingKind::Let = kind {
            self.variable_nesting += 1;
        }
    }

    fn up(&mut self, kind: crate::visitor::NestingKind) {
        if let crate::visitor::NestingKind::Let = kind {
            self.variable_nesting -= 1;
        }
    }

    fn visit_group(&mut self, group: &exprs::Group) -> Result<(), CompileError> {
        match &group.kind {
            GroupKind::Capturing(Capture { name: Some(name) }) => {
                if self.variable_nesting > 0 {
                    return Err(CompileErrorKind::CaptureInLet.at(group.span));
                }

                if self.names.contains_key(name) {
                    return Err(
                        CompileErrorKind::NameUsedMultipleTimes(name.to_string()).at(group.span)
                    );
                }

                self.count_named += 1;
                let index = CapturingGroupIndex {
                    from_named: self.count_named,
                    absolute: self.count_named + self.count_numbered,
                };
                self.names.insert(name.to_string(), index);
            }
            GroupKind::Capturing(Capture { name: None }) => {
                if self.variable_nesting > 0 {
                    return Err(CompileErrorKind::CaptureInLet.at(group.span));
                }

                self.count_numbered += 1;
            }
            _ => {}
        }

        Ok(())
    }

    fn visit_reference(&mut self, reference: &exprs::Reference) -> Result<(), CompileError> {
        if self.variable_nesting > 0 {
            return Err(CompileErrorKind::ReferenceInLet.at(reference.span));
        }
        Ok(())
    }
}