typstfmt 0.1.0

A soon to be formatter for the typst lang
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

use tracing::warn;

use super::*;

#[instrument(skip_all)]
pub(crate) fn format_args(parent: &LinkedNode, children: &[String], ctx: &mut Ctx) -> String {
    if children.iter().any(|c| c.contains('\n')) {
        return format_args_breaking(parent, children, ctx);
    }

    let mut res = format_args_one_line(parent, children, ctx);
    let number_of_args = parent
        .children()
        .filter_map(|node| {
            if [Comma, Space, LeftParen, RightParen].contains(&node.kind()) {
                None
            } else {
                Some(node)
            }
        })
        .count();

    if number_of_args <= 1 {
        return res;
    }

    if utils::max_line_length(&res) >= ctx.config.max_line_length {
        debug!("format_args::breaking");
        res = format_args_breaking(parent, children, ctx);
        return res;
    }
    debug!("format_args::one_line");
    res
}

pub(crate) fn format_args_one_line(
    parent: &LinkedNode<'_>,
    children: &[String],
    ctx: &mut Ctx,
) -> String {
    let mut res = String::new();
    for (s, node) in children.iter().zip(parent.children()) {
        match node.kind() {
            Space => {}
            Comma => {
                if utils::next_is_ignoring(&node, RightParen, &[Space]) {
                    // not putting the comma in would result in a parenthesized expression, not an array
                    // "(a,) != (a)"
                    if node.parent_kind() == Some(Array) {
                        ctx.push_raw_in(",", &mut res)
                    }
                    // don't print
                } else {
                    ctx.push_raw_in(s, &mut res);
                    ctx.push_in(" ", &mut res);
                }
            }
            _ => {
                ctx.push_raw_in(s, &mut res);
            }
        }
    }
    res
}

pub(crate) fn format_args_breaking(
    parent: &LinkedNode<'_>,
    children: &[String],
    ctx: &mut Ctx,
) -> String {
    let mut res = String::new();
    let mut missing_trailing = false;
    for (s, node) in children.iter().zip(parent.children()) {
        match node.kind() {
            LeftParen => {
                res.push_str(s);
                res.push('\n');
                res.push_str(&ctx.get_indent());
                if let Some(next) = utils::get_next_ignoring(&node, &[Space]) {
                    if [LineComment, BlockComment].contains(&next.kind()) {
                        res.push_str(next.text());
                        res.push('\n');
                        res.push_str(&ctx.get_indent());
                    }
                }
            }
            RightParen => {
                res.push_str(s);
            }
            LineComment | BlockComment => {
                // this will be dealt with in comma and leftParen.
            }
            Space => {}
            // handles trailing comma
            // handles Line comment
            //
            Comma => {
                // print the last comma but don't indent
                let is_last_comma = utils::find_next(&node, &|x| x.kind() == Comma).is_none();
                // will be false if trivia is in the way
                let is_trailing = utils::next_is_ignoring(&node, RightParen, &[Space]);

                if is_last_comma && is_trailing {
                    // no indent
                    assert!(s == ",");
                    ctx.push_raw_in(s, &mut res);
                    if utils::next_is_ignoring(&node, RightParen, &[Space]) {}
                    ctx.push_raw_in("\n", &mut res);
                } else {
                    ctx.push_raw_in(&format!("{s}\n{}", ctx.get_indent()), &mut res);
                    if let Some(next) = utils::get_next_ignoring(&node, &[Space]) {
                        if [LineComment, BlockComment].contains(&next.kind()) {
                            res.push_str(next.text());
                            res.push('\n');
                            let is_trailing = utils::next_is_ignoring(&next, RightParen, &[Space]);
                            if !is_trailing {
                                res.push_str(&ctx.get_indent());
                            }
                        }
                    }

                    if is_last_comma && !is_trailing {
                        missing_trailing = true;
                    }
                }
            }
            _ => {
                ctx.push_raw_indent(s, &mut res);
                let is_last = utils::next_is_ignoring(&node, RightParen, &[Space]);
                if is_last && missing_trailing {
                    ctx.push_raw_in(",\n", &mut res)
                }
            }
        }
    }
    res
}