tree-sitter-sg 0.27.0

Rust bindings to the Tree-sitter parsing library
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
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::ffi::{TSInputEdit, TSPoint};

use super::utils::{ptr_mut, ptr_ref};

pub const POINT_MAX: TSPoint = TSPoint {
    row: u32::MAX,
    column: u32::MAX,
};

#[inline]
pub const fn point_new(row: u32, column: u32) -> TSPoint {
    TSPoint { row, column }
}

#[inline]
pub const fn point_add(a: TSPoint, b: TSPoint) -> TSPoint {
    if b.row > 0 {
        point_new(a.row + b.row, b.column)
    } else {
        point_new(a.row, a.column + b.column)
    }
}

#[inline]
pub const fn point_sub(a: TSPoint, b: TSPoint) -> TSPoint {
    if a.row > b.row {
        point_new(a.row - b.row, a.column)
    } else {
        point_new(0, a.column.saturating_sub(b.column))
    }
}

#[inline]
pub const fn point_lte(a: TSPoint, b: TSPoint) -> bool {
    (a.row < b.row) || (a.row == b.row && a.column <= b.column)
}

#[inline]
pub const fn point_lt(a: TSPoint, b: TSPoint) -> bool {
    (a.row < b.row) || (a.row == b.row && a.column < b.column)
}

#[inline]
pub const fn point_gt(a: TSPoint, b: TSPoint) -> bool {
    (a.row > b.row) || (a.row == b.row && a.column > b.column)
}

#[inline]
pub const fn point_gte(a: TSPoint, b: TSPoint) -> bool {
    (a.row > b.row) || (a.row == b.row && a.column >= b.column)
}

#[inline]
pub const fn point_eq(a: TSPoint, b: TSPoint) -> bool {
    a.row == b.row && a.column == b.column
}

/// Apply an input edit to a byte/point pair.
///
/// Positions after the old edit end are translated by the edit delta. Positions
/// inside the replaced range collapse to the new edit end, which is the same
/// convention used for subtree and range edits.
pub fn point_edit(point: &mut TSPoint, byte: &mut u32, edit: &TSInputEdit) {
    let start_byte = *byte;
    let start_point = *point;

    if start_byte >= edit.old_end_byte {
        *byte = edit.new_end_byte + (start_byte - edit.old_end_byte);
        *point = point_add(
            edit.new_end_point,
            point_sub(start_point, edit.old_end_point),
        );
    } else if start_byte > edit.start_byte {
        *byte = edit.new_end_byte;
        *point = edit.new_end_point;
    }
}

/// C-compatible entry point for editing a byte/point pair.
///
/// # Safety
/// `point`, `byte`, and `edit` must be valid, non-null pointers.
#[no_mangle]
pub unsafe extern "C" fn ts_point_edit(
    point: *mut TSPoint,
    byte: *mut u32,
    edit: *const TSInputEdit,
) {
    let point = ptr_mut(point);
    let byte = ptr_mut(byte);
    let edit = ptr_ref(edit);

    point_edit(point, byte, edit);
}

#[cfg(test)]
mod tests {
    use super::*;

    fn edit() -> TSInputEdit {
        TSInputEdit {
            start_byte: 5,
            old_end_byte: 10,
            new_end_byte: 12,
            start_point: point_new(0, 5),
            old_end_point: point_new(0, 10),
            new_end_point: point_new(1, 2),
        }
    }

    fn assert_point_eq(actual: TSPoint, expected: TSPoint) {
        assert_eq!(actual.row, expected.row);
        assert_eq!(actual.column, expected.column);
    }

    #[test]
    fn edit_point_after_changed_range() {
        let mut point = point_new(0, 14);
        let mut byte = 14;

        point_edit(&mut point, &mut byte, &edit());

        assert_eq!(byte, 16);
        assert_point_eq(point, point_new(1, 6));
    }

    #[test]
    fn edit_point_inside_changed_range() {
        let mut point = point_new(0, 7);
        let mut byte = 7;

        point_edit(&mut point, &mut byte, &edit());

        assert_eq!(byte, 12);
        assert_point_eq(point, point_new(1, 2));
    }

    #[test]
    fn edit_point_before_changed_range() {
        let mut point = point_new(0, 4);
        let mut byte = 4;

        point_edit(&mut point, &mut byte, &edit());

        assert_eq!(byte, 4);
        assert_point_eq(point, point_new(0, 4));
    }
}