tree-sitter-graph 0.12.0

Construct graphs from parsed source code
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

// -*- coding: utf-8 -*-
// ------------------------------------------------------------------------------------------------
// Copyright © 2022, tree-sitter authors.
// Licensed under either of Apache License, Version 2.0, or MIT license, at your option.
// Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
// ------------------------------------------------------------------------------------------------

use indoc::indoc;
use tree_sitter::Parser;
use tree_sitter::Point;
use tree_sitter::Tree;
use tree_sitter_graph::parse_error::ParseError;

fn init_log() {
    let _ = env_logger::builder()
        .is_test(true)
        .format_level(false)
        .format_target(false)
        .format_timestamp(None)
        .try_init(); // try, because earlier test may have already initialized it
}

fn parse(python_source: &str) -> Tree {
    init_log();
    let mut parser = Parser::new();
    parser
        .set_language(&tree_sitter_python::LANGUAGE.into())
        .unwrap();
    parser.parse(python_source, None).unwrap()
}

#[test]
fn can_find_error() {
    let tree = parse(indoc! {r#"
        def f():
            a 42
        def g():
            pass
    "#});
    let parse_error = ParseError::first(&tree);
    let position = parse_error.map(|e| e.node().start_position());
    assert_eq!(position, Some(Point::new(1, 4)));
}

#[test]
fn can_find_errors() {
    let tree = parse(indoc! {r#"
        def f():
            a 42
        def g():
            b 11
    "#});
    let parse_errors = ParseError::all(&tree);
    let positions = parse_errors
        .into_iter()
        .map(|e| e.node().start_position())
        .collect::<Vec<_>>();
    assert_eq!(positions, vec![Point::new(1, 4), Point::new(3, 4)]);
}

#[test]
fn can_move_tree_with_error() {
    let tree = parse(indoc! {r#"
        def f():
            a 42
        def g():
            pass
    "#});
    let parse_error = ParseError::into_first(tree);
    let moved_parse_error = parse_error;
    let position = moved_parse_error
        .error()
        .as_ref()
        .map(|e| e.node().start_position());
    assert_eq!(position, Some(Point::new(1, 4)));
    let _recovered_tree = moved_parse_error.into_tree();
}

#[test]
fn can_move_tree_with_errors() {
    let tree = parse(indoc! {r#"
        def f():
            a 42
        def g():
            b 11
    "#});
    let parse_errors = ParseError::into_all(tree);
    let moved_parse_errors = parse_errors;
    let positions = moved_parse_errors
        .errors()
        .iter()
        .map(|e| e.node().start_position())
        .collect::<Vec<_>>();
    assert_eq!(positions, vec![Point::new(1, 4), Point::new(3, 4)]);
    let _recovered_tree = moved_parse_errors.into_tree();
}