firedbg-rust-parser 1.0.0

FireDBG Source Parser for Rust
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

use crate::BreakableSpan;
use firedbg_protocol::source::LineColumn;
use syn::spanned::Spanned;

pub(crate) fn parse_body_loc(block: &syn::Block) -> BreakableSpan {
    BreakableSpan {
        start: parse_body_loc_start(block),
        end: parse_body_loc_end(block),
    }
}

/// Parse the line and column number of function block.
///
/// A function block is wrapped in a pair of braces, i.e. `{ ... }`
pub(crate) fn parse_body_loc_start(block: &syn::Block) -> LineColumn {
    // Given a function like... the `loc.column` will be at
    //   - `fn func<T>(i: T) -> T where T: Into<u64> { `
    //                                              ^
    //   - `fn func<T>(i: T) -> T where T: Into<u64>{ `
    //                                             ^
    //   - `fn func() { `
    //               ^
    //   - `fn func(){ `
    //              ^
    // However, we want the `loc.column` to be one character after `{`, i.e.
    //   - `fn func<T>(i: T) -> T where T: Into<u64> { `
    //                                                ^
    //   - `fn func<T>(i: T) -> T where T: Into<u64>{ `
    //                                               ^
    //   - `fn func() { `
    //                 ^
    //   - `fn func(){ `
    //                ^
    let mut loc: LineColumn = block.span().start().into_loc();
    // Hence, `loc.column + 2`
    if let Some(col) = loc.column.as_mut() {
        *col += 2;
    }
    loc
}

/// Parse the line and column number of function block.
///
/// A function block is wrapped in a pair of braces, i.e. `{ ... }`
///
/// 1. If the function block is empty, this function will return the result of [parse_body_loc_start] function
///
/// 2. If the function block has statement in it, this function will return the line and column number of the beginning of first statement.
///
/// ```compile_fail
/// fn hello_3(world: &World) { println!("hello {}", world) }
///                             ^
///
/// fn hello_5(world: &World) { let world = World { nth: 99 }; println!("hello {}", world) }
///                             ^
///
/// fn hello_7(world:&World){let world=World{nth:99};println!("hello {}",world)}
///                          ^
///
/// fn hello_15(world: &World) {let world=World{nth:99};
///                             ^
/// println!("hello {}",world)}
///
/// fn hello_17(world: &World) { let world=World{nth:99};
///                              ^
/// println!("hello {}",world)}
///
/// fn hello_13(world: &World) {
/// let world=World{nth:99};
/// ^
///         println!("hello {}",world)}
///
/// fn hello_19(world: &World) {
///     
///     let world=World{nth:99};
///     ^
///     println!("hello {}",world)
///
/// }
///
/// impl Display for World {
///     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
///         write!(f, "{}th world", self.nth)
///         ^
///     }
/// }
/// ```
fn parse_body_loc_end(block: &syn::Block) -> LineColumn {
    let mut loc = parse_body_loc_start(block);
    if let Some(first_stmt) = block.stmts.first() {
        let mut first_stmt_loc: LineColumn = first_stmt.span().start().into_loc();
        if let Some(col) = first_stmt_loc.column.as_mut() {
            *col += 1;
        }
        loc = first_stmt_loc;
    }
    loc
}

pub(crate) trait IntoLineColumn {
    fn into_loc(self) -> LineColumn;
}

impl IntoLineColumn for proc_macro2::LineColumn {
    fn into_loc(self) -> LineColumn {
        LineColumn {
            line: self.line as u32,
            column: Some(self.column as u32),
        }
    }
}