xee-xpath-ast 0.1.4

XPath parser and AST implementation
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

use ahash::{HashSet, HashSetExt};

use crate::Name;
use crate::{ast, span::WithSpan, VariableNames};

use super::visitor::AstVisitor;

struct UniqueNameGenerator {
    names: HashSet<Name>,
}

impl UniqueNameGenerator {
    fn new() -> Self {
        UniqueNameGenerator {
            names: HashSet::new(),
        }
    }

    fn generate(&mut self, name: &Name) -> Name {
        let mut name = name.clone();
        while self.names.contains(&name) {
            name = name.with_suffix();
        }
        self.names.insert(name.clone());
        name
    }
}

struct Names {
    names: Vec<(Name, Name)>,
    generator: UniqueNameGenerator,
}

impl Names {
    fn new() -> Self {
        Names {
            names: Vec::new(),
            generator: UniqueNameGenerator::new(),
        }
    }

    fn get(&mut self, name: &Name) -> Name {
        // this always returns a name, even if the
        // name is unknown, in which case a unique bogus
        // name is generated
        self.names
            .iter()
            .rev()
            .find(|(old_name, _)| old_name == name)
            .map(|(_, new_name)| new_name.clone())
            .unwrap_or_else(|| self.generator.generate(name))
    }

    fn push_name(&mut self, name: &Name) -> Name {
        let new_name = self.generator.generate(name);
        self.names.push((name.clone(), new_name.clone()));
        new_name
    }

    fn pop_name(&mut self) {
        self.names.pop();
    }
}

struct Renamer {
    names: Names,
}

impl Renamer {
    fn new() -> Self {
        Renamer {
            names: Names::new(),
        }
    }

    fn push_name(&mut self, name: &Name) -> Name {
        self.names.push_name(name)
    }

    fn pop_name(&mut self) {
        self.names.pop_name();
    }
}

impl AstVisitor for Renamer {
    fn visit_let_expr(&mut self, expr: &mut ast::LetExpr) {
        self.visit_expr_single(&mut expr.var_expr);
        let old_span = expr.var_name.span;
        expr.var_name = self.push_name(&expr.var_name.value).with_span(old_span);
        self.visit_expr_single(&mut expr.return_expr);
        self.pop_name();
    }

    fn visit_for_expr(&mut self, expr: &mut ast::ForExpr) {
        self.visit_expr_single(&mut expr.var_expr);
        let old_span = expr.var_name.span;
        expr.var_name = self.push_name(&expr.var_name.value).with_span(old_span);
        self.visit_expr_single(&mut expr.return_expr);
        self.pop_name();
    }

    fn visit_quantified_expr(&mut self, expr: &mut ast::QuantifiedExpr) {
        self.visit_expr_single(&mut expr.var_expr);
        let old_span = expr.var_name.span;
        expr.var_name = self.push_name(&expr.var_name.value).with_span(old_span);
        self.visit_expr_single(&mut expr.satisfies_expr);
        self.pop_name();
    }

    fn visit_inline_function(&mut self, expr: &mut ast::InlineFunction) {
        for param in &mut expr.params {
            param.name = self.push_name(&param.name);
        }
        self.visit_expr_or_empty(&mut expr.body);
        for _ in &expr.params {
            self.pop_name();
        }
    }

    fn visit_var_ref(&mut self, name: &mut Name) {
        let new_name = self.names.get(name);
        *name = new_name;
    }
}

pub(crate) fn unique_names(expr: &mut ast::XPath, variable_names: &VariableNames) {
    let mut renamer = Renamer::new();
    // ensure we know of the outer variable names too;
    // these are never going to be changed as there isn't
    // any other shadowing yet at this point
    for name in variable_names {
        renamer.push_name(name);
    }
    renamer.visit_xpath(expr);
}