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

use std::{
    path::{Path, PathBuf},
    rc::Rc,
    ops::Range,
    cmp::Ordering,
};

#[derive(Debug)]
struct IndexEntry {
    name: Rc<PathBuf>,
    start: usize,
    range: Range<usize>,
}

/// Index that maps generated code locations to their origins
pub struct Index {
    segs: Vec<IndexEntry>,
    size: usize,
}

impl Index {
    fn new() -> Self {
        Self {
            segs: Vec::new(),
            size: 0,
        }
    }

    fn push(&mut self, name: Rc<PathBuf>, start: usize, size: usize) {
        self.segs.push(IndexEntry {
            name, start,
            range: self.size..(self.size + size),
        });
        self.size += size;
    }

    fn append(&mut self, mut index: Index) {
        for seg in index.segs.iter_mut() {
            let r = &mut seg.range;
            r.start += self.size;
            r.end += self.size;
        }
        self.segs.append(&mut index.segs);
        self.size += index.size;
    }

    /// Maps line number in generated code to source file name and position in it
    pub fn search(&self, pos: usize) -> Option<(PathBuf, usize)> {
        match self.segs.binary_search_by(|seg| {
            if pos < seg.range.start {
                Ordering::Greater
            } else if pos >= seg.range.end {
                Ordering::Less
            } else {
                Ordering::Equal
            }
        }) {
            Ok(i) => {
                let seg = &self.segs[i];
                Some(((*seg.name).clone(), pos - seg.range.start + seg.start))
            },
            Err(_) => None,
        }
    }
}

/// Tree of parsed source files
pub struct Node {
    name: PathBuf,
    inner: Vec<(Node, usize)>,
    text: String,
    index: Vec<Range<usize>>,
}

impl Node {
    pub(crate) fn new(name: &Path) -> Self {
        Self {
            name: name.to_path_buf(),
            inner: Vec::new(),
            text: String::new(),
            index: Vec::new(),
        }
    }

    pub fn name(&self) -> &Path {
        &self.name
    }

    pub(crate) fn add_line(&mut self, line: &str) {
        let plen = self.text.len();
        self.text.push_str(line.trim_end());
        self.text.push('\n');
        self.index.push(plen..self.text.len());
    }

    pub(crate) fn add_child(&mut self, node: Node) {
        self.add_line("");
        self.inner.push((node, self.index.len() - 1));
    }

    pub fn lines_count(&self) -> usize {
        self.index.len()
    }

    /// Generates resulting code string and mapping index for it
    pub fn collect(&self) -> (String, Index) {
        let mut accum = String::new();
        let mut index = Index::new();

        let name = Rc::new(self.name.clone());

        let mut ppos = 0;
        for (node, pos) in self.inner.iter() {
            let start = self.index[ppos].start;
            let end = self.index[*pos].end;

            accum.push_str(&self.text[start..end]);
            index.push(name.clone(), ppos, pos - ppos + 1);

            let (child_str, child_index) = node.collect();
            accum.push_str(&child_str);
            index.append(child_index);

            ppos = *pos + 1;
        }

        if ppos < self.index.len() {
            accum.push_str(&self.text[self.index[ppos].start..]);
            index.push(name.clone(), ppos, self.index.len() - ppos);
        }

        (accum, index)
    }
}