lisette-semantics 0.1.0

Little language inspired by Rust that compiles to Go
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

use syntax::ast::Span;

use crate::checker::Checker;

impl Checker<'_, '_> {
    pub(crate) fn check_return_in_try_block(&mut self, span: Span) {
        if self.scopes.lookup_try_block_context().is_some() {
            self.sink
                .push(diagnostics::infer::return_in_try_block(span));
        }
    }

    pub(crate) fn check_break_outside_loop(&mut self, span: Span) {
        // Only emit the generic "break outside loop" error when not in a
        // try/recover/defer block, since those have their own more specific errors.
        if !self.scopes.is_inside_loop()
            && self.scopes.lookup_try_block_context().is_none()
            && self.scopes.lookup_recover_block_context().is_none()
            && !self.scopes.is_inside_defer_block()
        {
            self.sink.push(diagnostics::infer::break_outside_loop(span));
        }
    }

    pub(crate) fn check_continue_outside_loop(&mut self, span: Span) {
        // Only emit the generic "continue outside loop" error when not in a
        // try/recover/defer block, since those have their own more specific errors.
        if !self.scopes.is_inside_loop()
            && self.scopes.lookup_try_block_context().is_none()
            && self.scopes.lookup_recover_block_context().is_none()
            && !self.scopes.is_inside_defer_block()
        {
            self.sink
                .push(diagnostics::infer::continue_outside_loop(span));
        }
    }

    pub(crate) fn check_break_in_try_block(&mut self, span: Span) {
        if let Some(ctx) = self.scopes.lookup_try_block_context()
            && !ctx.loop_depth.is_active()
        {
            self.sink.push(diagnostics::infer::break_in_try_block(span));
        }
    }

    pub(crate) fn check_continue_in_try_block(&mut self, span: Span) {
        if let Some(ctx) = self.scopes.lookup_try_block_context()
            && !ctx.loop_depth.is_active()
        {
            self.sink
                .push(diagnostics::infer::continue_in_try_block(span));
        }
    }

    pub(crate) fn check_return_in_recover_block(&mut self, span: Span) {
        if self.scopes.lookup_recover_block_context().is_some() {
            self.sink
                .push(diagnostics::infer::return_in_recover_block(span));
        }
    }

    pub(crate) fn check_break_in_recover_block(&mut self, span: Span) {
        if let Some(ctx) = self.scopes.lookup_recover_block_context()
            && !ctx.loop_depth.is_active()
        {
            self.sink
                .push(diagnostics::infer::break_in_recover_block(span));
        }
    }

    pub(crate) fn check_continue_in_recover_block(&mut self, span: Span) {
        if let Some(ctx) = self.scopes.lookup_recover_block_context()
            && !ctx.loop_depth.is_active()
        {
            self.sink
                .push(diagnostics::infer::continue_in_recover_block(span));
        }
    }

    pub(crate) fn check_return_in_defer_block(&mut self, span: Span) {
        if self.scopes.is_inside_defer_block() {
            self.sink
                .push(diagnostics::infer::return_in_defer_block(span));
        }
    }

    pub(crate) fn check_break_in_defer_block(&mut self, span: Span) {
        if self.scopes.is_inside_defer_block() && self.scopes.defer_block_loop_depth() == 0 {
            self.sink
                .push(diagnostics::infer::break_in_defer_block(span));
        }
    }

    pub(crate) fn check_continue_in_defer_block(&mut self, span: Span) {
        if self.scopes.is_inside_defer_block() && self.scopes.defer_block_loop_depth() == 0 {
            self.sink
                .push(diagnostics::infer::continue_in_defer_block(span));
        }
    }
}