relux 0.3.0

Expect-style integration test framework for interactive shell programs
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

use crate::core::table::FileId;
use crate::diagnostics::CycleReport;
use crate::diagnostics::InvalidReport;
use crate::diagnostics::LoweringBail;

pub use crate::dsl::resolver::lower::LoweringContext;

/// Trait for lowering AST nodes into IR nodes with optional caching
/// and cycle detection. Default implementations provide no-op behavior
/// for non-cacheable types — only `lower` must be implemented.
pub trait IrNodeLowering: Sized + Clone {
    type Ast;

    /// Return `None` for non-cacheable types (default).
    /// Return `Some(Some(result))` if already resolved.
    /// Return `Some(None)` if cacheable but not yet visited.
    fn cached(
        _ast: &Self::Ast,
        _ctx: &LoweringContext,
    ) -> Option<Option<Result<Self, LoweringBail>>> {
        None
    }

    fn cache(_ast: &Self::Ast, _result: Result<Self, LoweringBail>, _ctx: &mut LoweringContext) {}

    fn check_cycle(_ast: &Self::Ast, _ctx: &LoweringContext) -> Option<CycleReport> {
        None
    }

    fn push_in_progress(_ast: &Self::Ast, _ctx: &mut LoweringContext) {}

    fn pop_in_progress(_ctx: &mut LoweringContext) {}

    /// AST → IR lowering for a single node.
    fn lower(
        ast: &Self::Ast,
        file: &FileId,
        ctx: &mut LoweringContext,
    ) -> Result<Self, LoweringBail>;

    /// Orchestrates caching, cycle detection, and lowering.
    fn from_ast(
        ast: &Self::Ast,
        file: &FileId,
        ctx: &mut LoweringContext,
    ) -> Result<Self, LoweringBail> {
        match Self::cached(ast, ctx) {
            None => Self::lower(ast, file, ctx),
            Some(Some(result)) => result,
            Some(None) => {
                if let Some(cycle) = Self::check_cycle(ast, ctx) {
                    let bail = LoweringBail::invalid(InvalidReport::cycle(cycle));
                    Self::cache(ast, Err(bail.clone()), ctx);
                    return Err(bail);
                }
                Self::push_in_progress(ast, ctx);
                let result = Self::lower(ast, file, ctx);
                Self::pop_in_progress(ctx);
                Self::cache(ast, result.clone(), ctx);
                result
            }
        }
    }
}