brink-ir 0.0.17

Intermediate representations for inkle's ink narrative scripting language
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

use brink_syntax::ast::{self, AstNode};

use crate::provenance::NodeClass;

use crate::Stmt;

use super::super::context::{LowerScope, LowerSink};
use super::super::expr::LowerExpr;
use super::sequence::lower_block_sequence;
use super::{LowerConditional, LowerSequence};

// ─── Multiline block promotion ──────────────────────────────────────

/// Try to lower a `MultilineBlock` AST node into a statement.
///
/// The returned `Conditional`/`Sequence`'s `ptr` is rewritten to `mb`'s own
/// range (not the inner `conditional`/`branches_cond`/`sequence` node's
/// range that `lower_conditional`/`lower_block_sequence` stamp) — `mb` is
/// the node that actually owns the enclosing `{`/`}` braces. Editor line
/// classification (`brink-ide::line_context`'s conditional-scaffold pass,
/// #413) walks this range to classify the braces and any `- cond:`/`-
/// else:` branch headers as `Logic`; without this correction, the opening
/// brace line falls outside every statement's range and is left `Blank`.
pub fn lower_multiline_block(
    mb: &ast::MultilineBlock,
    scope: &LowerScope,
    sink: &mut impl LowerSink,
) -> Option<Stmt> {
    let cond_ptr = scope.prov(NodeClass::Conditional, mb.syntax());
    let seq_ptr = scope.prov(NodeClass::Sequence, mb.syntax());

    if let Some(cond) = mb.conditional()
        && let Ok(mut c) = cond.lower_conditional(scope, sink)
    {
        c.ptr = cond_ptr;
        return Some(Stmt::Conditional(c));
    }

    if let Some(seq) = mb.sequence()
        && seq.multiline_branches().is_some()
    {
        let mut s = lower_block_sequence(&seq, scope, sink);
        s.ptr = seq_ptr;
        return Some(Stmt::Sequence(s));
    }

    if let Some(branches) = mb.branches_cond()
        && let Ok(mut c) = branches.lower_conditional(scope, sink)
    {
        c.ptr = cond_ptr;
        return Some(Stmt::Conditional(c));
    }

    None
}

/// Try to promote an `InlineLogic` node to a block-level statement.
pub fn lower_multiline_block_from_inline(
    inline: &ast::InlineLogic,
    scope: &LowerScope,
    sink: &mut impl LowerSink,
) -> Option<Stmt> {
    // Same brace-inclusion correction as `lower_multiline_block` above:
    // `inline` (`{`...`}`) always encloses the inner conditional/sequence
    // node it wraps, so its own range is the true scaffold anchor.
    let cond_ptr = scope.prov(NodeClass::Conditional, inline.syntax());
    let seq_ptr = scope.prov(NodeClass::Sequence, inline.syntax());

    if let Some(ml_cond) = inline.multiline_conditional()
        && let Ok(mut c) = ml_cond.lower_conditional(scope, sink)
    {
        c.ptr = cond_ptr;
        return Some(Stmt::Conditional(c));
    }

    if let Some(cond) = inline.conditional()
        && (cond.multiline_branches().is_some() || cond.branchless_body().is_some())
        && let Ok(mut c) = cond.lower_conditional(scope, sink)
    {
        c.ptr = cond_ptr;
        return Some(Stmt::Conditional(c));
    }

    if let Some(seq) = inline.sequence()
        && seq.multiline_branches().is_some()
    {
        let mut s = lower_block_sequence(&seq, scope, sink);
        s.ptr = seq_ptr;
        return Some(Stmt::Sequence(s));
    }

    None
}

// ─── Inline logic → content parts ───────────────────────────────────

/// Lower inline logic into content parts (value interpolation, inline
/// conditional, or inline sequence).
pub fn lower_inline_logic_into_parts(
    inline: &ast::InlineLogic,
    parts: &mut Vec<crate::ContentPart>,
    scope: &LowerScope,
    sink: &mut impl LowerSink,
) {
    if let Some(inner) = inline.inner_expression()
        && let Some(expr) = inner.expr().and_then(|e| e.lower_expr(scope, sink).ok())
    {
        parts.push(crate::ContentPart::Interpolation(expr));
        return;
    }

    if let Some(cond) = inline.conditional()
        && let Ok(ic) = cond.lower_conditional(scope, sink)
    {
        parts.push(crate::ContentPart::InlineConditional(ic));
        return;
    }

    if let Some(seq) = inline.sequence()
        && let Ok(is) = seq.lower_sequence(scope, sink)
    {
        parts.push(crate::ContentPart::InlineSequence(is));
        return;
    }

    if let Some(imp) = inline.implicit_sequence()
        && let Ok(is) = imp.lower_sequence(scope, sink)
    {
        parts.push(crate::ContentPart::InlineSequence(is));
    }
}