chloro-core 0.7.5

Core functionality for chloro - a minimal Rust code formatter
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

#![allow(dead_code)]

#[cfg(debug_assertions)]
use ra_ap_syntax::{NodeOrToken, SyntaxNode};

#[cfg(debug_assertions)]
pub fn debug_node_siblings(node: &SyntaxNode, label: &str, max_depth: usize) {
    eprintln!("=== {} ===", label);
    eprintln!("Node prev_sibling_or_token:");
    let mut prev = node.prev_sibling_or_token();
    let mut i = 0;
    while let Some(p) = prev {
        match &p {
            NodeOrToken::Token(t) => {
                eprintln!("  [{}] Token: {:?} = {:?}", i, t.kind(), t.text());
            }
            NodeOrToken::Node(n) => {
                eprintln!("  [{}] Node: {:?}", i, n.kind());
            }
        }
        prev = match p {
            NodeOrToken::Token(t) => t.prev_sibling_or_token(),
            NodeOrToken::Node(n) => n.prev_sibling_or_token(),
        };
        i += 1;
        if i >= max_depth {
            break;
        }
    }
    eprintln!("=== END {} ===", label);
}

#[cfg(debug_assertions)]
pub fn debug_children_with_tokens(node: &SyntaxNode, label: &str, max_depth: usize) {
    eprintln!("=== {} ===", label);
    for (i, child) in node.children_with_tokens().enumerate() {
        match &child {
            NodeOrToken::Token(t) => {
                eprintln!("  [{}] Token: {:?} = {:?}", i, t.kind(), t.text());
            }
            NodeOrToken::Node(n) => {
                eprintln!("  [{}] Node: {:?}", i, n.kind());
                if n.kind() == ra_ap_syntax::SyntaxKind::VARIANT {
                    eprintln!("    Variant prev_sibling_or_token:");
                    let mut prev = n.prev_sibling_or_token();
                    let mut j = 0;
                    while let Some(p) = prev {
                        match &p {
                            NodeOrToken::Token(t) => {
                                eprintln!("      [{}] Token: {:?} = {:?}", j, t.kind(), t.text());
                            }
                            NodeOrToken::Node(pn) => {
                                eprintln!("      [{}] Node: {:?}", j, pn.kind());
                            }
                        }
                        prev = match p {
                            NodeOrToken::Token(t) => t.prev_sibling_or_token(),
                            NodeOrToken::Node(n) => n.prev_sibling_or_token(),
                        };
                        j += 1;
                        if j >= max_depth {
                            break;
                        }
                    }
                }
            }
        }
    }
    eprintln!("=== END {} ===", label);
}

#[cfg(not(debug_assertions))]
pub fn debug_node_siblings(_node: &ra_ap_syntax::SyntaxNode, _label: &str, _max_depth: usize) {}

#[cfg(not(debug_assertions))]
pub fn debug_children_with_tokens(
    _node: &ra_ap_syntax::SyntaxNode,
    _label: &str,
    _max_depth: usize,
) {
}