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

use crate::lexer::token::TokenKind;
use crate::parser::ast::try_block::CatchBlock;
use crate::parser::ast::try_block::CatchType;
use crate::parser::ast::try_block::FinallyBlock;
use crate::parser::ast::try_block::TryStatement;
use crate::parser::ast::Statement;
use crate::parser::error;
use crate::parser::error::ParseResult;
use crate::parser::internal::blocks;
use crate::parser::internal::identifiers;
use crate::parser::internal::utils;
use crate::parser::state::State;

use super::variables;

pub fn try_block(state: &mut State) -> ParseResult<Statement> {
    let start = state.stream.current().span;

    state.stream.next();
    utils::skip_left_brace(state)?;

    let body = blocks::multiple_statements_until(state, &TokenKind::RightBrace)?;

    let last_right_brace = utils::skip_right_brace(state)?;

    let mut catches = Vec::new();
    loop {
        if state.stream.current().kind != TokenKind::Catch {
            break;
        }

        let catch_start = state.stream.current().span;

        state.stream.next();
        utils::skip_left_parenthesis(state)?;

        let types = catch_type(state)?;
        let var = if state.stream.current().kind == TokenKind::RightParen {
            None
        } else {
            Some(variables::simple_variable(state)?)
        };

        utils::skip_right_parenthesis(state)?;
        utils::skip_left_brace(state)?;

        let catch_body = blocks::multiple_statements_until(state, &TokenKind::RightBrace)?;

        utils::skip_right_brace(state)?;

        let catch_end = state.stream.current().span;

        catches.push(CatchBlock {
            start: catch_start,
            end: catch_end,
            types,
            var,
            body: catch_body,
        })
    }

    let mut finally = None;
    if state.stream.current().kind == TokenKind::Finally {
        let finally_start = state.stream.current().span;
        state.stream.next();
        utils::skip_left_brace(state)?;

        let finally_body = blocks::multiple_statements_until(state, &TokenKind::RightBrace)?;

        utils::skip_right_brace(state)?;
        let finally_end = state.stream.current().span;

        finally = Some(FinallyBlock {
            start: finally_start,
            end: finally_end,
            body: finally_body,
        });
    }

    if catches.is_empty() && finally.is_none() {
        return Err(error::try_without_catch_or_finally(start, last_right_brace));
    }

    let end = state.stream.current().span;

    Ok(Statement::Try(TryStatement {
        start,
        end,
        body,
        catches,
        finally,
    }))
}

#[inline(always)]
fn catch_type(state: &mut State) -> ParseResult<CatchType> {
    let id = identifiers::full_name(state)?;

    if state.stream.current().kind == TokenKind::Pipe {
        state.stream.next();

        let mut types = vec![id];

        while !state.stream.is_eof() {
            let id = identifiers::full_name(state)?;
            types.push(id);

            if state.stream.current().kind != TokenKind::Pipe {
                break;
            }

            state.stream.next();
        }

        return Ok(CatchType::Union(types));
    }

    Ok(CatchType::Identifier(id))
}