yulang-runtime 0.1.1

Runtime IR, validation, monomorphization, and VM support for Yulang
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

use std::collections::HashMap;

use yulang_typed_ir as typed_ir;

use crate::ir::{Expr, ExprKind, Module, Stmt};
use crate::types::effect_paths;

#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub(crate) struct DemandSemantics {
    handler_bindings: HashMap<typed_ir::Path, Vec<typed_ir::Path>>,
}

impl DemandSemantics {
    pub(super) fn from_module(module: &Module) -> Self {
        let handler_bindings = module
            .bindings
            .iter()
            .filter_map(|binding| {
                expr_handler_consumes(&binding.body)
                    .map(|consumes| (binding.name.clone(), consumes))
            })
            .collect();
        Self { handler_bindings }
    }

    pub(super) fn is_effect_polymorphic_higher_order_target(
        &self,
        _target: &typed_ir::Path,
    ) -> bool {
        false
    }
}

pub(super) fn pure_handler_bindings(
    module: &Module,
) -> HashMap<typed_ir::Path, Vec<typed_ir::Path>> {
    module
        .bindings
        .iter()
        .filter_map(|binding| {
            expr_pure_handler_consumes(&binding.body)
                .map(|consumes| (binding.name.clone(), consumes))
        })
        .collect()
}

pub(super) fn consumed_effects_for_target(
    _semantics: &DemandSemantics,
    pure_handlers: &HashMap<typed_ir::Path, Vec<typed_ir::Path>>,
    target: &typed_ir::Path,
) -> Vec<typed_ir::Path> {
    pure_handlers.get(target).cloned().unwrap_or_default()
}

pub(super) fn known_consumed_effects_for_target(
    semantics: &DemandSemantics,
    target: &typed_ir::Path,
) -> Vec<typed_ir::Path> {
    semantics
        .handler_bindings
        .get(target)
        .cloned()
        .unwrap_or_default()
}

fn expr_handler_consumes(expr: &Expr) -> Option<Vec<typed_ir::Path>> {
    match &expr.kind {
        ExprKind::Handle { handler, .. } => Some(handler.consumes.clone()),
        ExprKind::Lambda { body, .. }
        | ExprKind::BindHere { expr: body }
        | ExprKind::Thunk { expr: body, .. }
        | ExprKind::LocalPushId { body, .. }
        | ExprKind::AddId { thunk: body, .. }
        | ExprKind::Coerce { expr: body, .. }
        | ExprKind::Pack { expr: body, .. } => expr_handler_consumes(body),
        ExprKind::Block {
            tail: Some(tail), ..
        } => expr_handler_consumes(tail),
        ExprKind::Block { stmts, tail: None } => match stmts.last() {
            Some(Stmt::Expr(expr)) => expr_handler_consumes(expr),
            _ => None,
        },
        _ => None,
    }
}

fn expr_pure_handler_consumes(expr: &Expr) -> Option<Vec<typed_ir::Path>> {
    match &expr.kind {
        ExprKind::Handle { handler, .. }
            if handler
                .residual_after
                .as_ref()
                .is_some_and(core_effect_is_empty) =>
        {
            Some(handler.consumes.clone())
        }
        ExprKind::Lambda { body, .. }
        | ExprKind::BindHere { expr: body }
        | ExprKind::Thunk { expr: body, .. }
        | ExprKind::LocalPushId { body, .. }
        | ExprKind::AddId { thunk: body, .. }
        | ExprKind::Coerce { expr: body, .. }
        | ExprKind::Pack { expr: body, .. } => expr_pure_handler_consumes(body),
        ExprKind::Block {
            tail: Some(tail), ..
        } => expr_pure_handler_consumes(tail),
        ExprKind::Block { stmts, tail: None } => match stmts.last() {
            Some(Stmt::Expr(expr)) => expr_pure_handler_consumes(expr),
            _ => None,
        },
        _ => None,
    }
}

fn core_effect_is_empty(effect: &typed_ir::Type) -> bool {
    matches!(effect, typed_ir::Type::Never)
        || matches!(
            effect,
            typed_ir::Type::Row { items, tail }
                if items.is_empty() && matches!(tail.as_ref(), typed_ir::Type::Never)
        )
        || effect_paths(effect).is_empty()
}