harn-vm 0.10.48

Async bytecode virtual machine for the Harn programming 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
132

use std::sync::Arc;

use harn_parser::{Node, SNode};

use super::{ensure_chunk_addressable, peel_node, CompileError, CompiledCallableEntry, Compiler};
use crate::chunk::Op;

impl Compiler {
    /// Compile a named pipeline for invocation with explicit host values.
    pub fn compile_named_pipeline_entry(
        mut self,
        program: &[SNode],
        pipeline_name: &str,
        fixture_name: Option<&str>,
    ) -> Result<CompiledCallableEntry, CompileError> {
        self.prepare_module_context(program);
        self.compile_entry_imports(program)?;
        self.compile_top_level_declarations(program)?;

        let fixture_expects_harness = fixture_name.is_some_and(|fixture_name| {
            program.iter().any(|node| {
                matches!(
                    peel_node(node),
                    Node::FnDecl { name, params, .. }
                        if name == fixture_name
                            && params.first().is_some_and(|param| matches!(
                                param.type_expr.as_ref(),
                                Some(harn_parser::TypeExpr::Named(name)) if name == "Harness"
                            ))
                )
            })
        });
        if let Some(fixture_name) = fixture_name {
            let fixture = self.string_constant(fixture_name);
            self.chunk.emit_u16(Op::GetVar, fixture, self.line);
        }
        let target = program.iter().find(
            |node| matches!(peel_node(node), Node::Pipeline { name, .. } if name == pipeline_name),
        );
        let Some(target) = target else {
            return Err(CompileError {
                message: format!("Unknown pipeline: {pipeline_name}"),
                line: self.line,
            });
        };
        let Node::Pipeline {
            name,
            body,
            extends,
            params,
            ..
        } = peel_node(target)
        else {
            unreachable!("pipeline target was matched above");
        };
        let expects_harness = params.first().is_some_and(|param| {
            matches!(
                param.type_expr.as_ref(),
                Some(harn_parser::TypeExpr::Named(name)) if name == "Harness"
            )
        });
        let callable =
            self.compile_pipeline_callable(program, name, params, body, extends.as_deref())?;
        let function_index = self.chunk.functions.len();
        self.chunk.functions.push(Arc::new(callable));
        self.chunk
            .emit_u16(Op::Closure, function_index as u16, self.line);
        if fixture_name.is_some() {
            self.chunk.emit_u16(Op::BuildList, 2, self.line);
        }
        self.chunk.emit(Op::Return, self.line);
        ensure_chunk_addressable(&self.chunk, "the callable entry", self.line)?;
        Ok(CompiledCallableEntry {
            bootstrap: self.chunk,
            has_fixture: fixture_name.is_some(),
            fixture_expects_harness,
            expects_harness,
        })
    }

    /// Compile a named function as a top-level callable entry.
    pub fn compile_named_function_entry(
        mut self,
        program: &[SNode],
        function_name: &str,
    ) -> Result<CompiledCallableEntry, CompileError> {
        self.prepare_module_context(program);
        self.compile_entry_imports(program)?;
        self.compile_top_level_declarations(program)?;
        let target = program.iter().find(
            |node| matches!(peel_node(node), Node::FnDecl { name, .. } if name == function_name),
        );
        let Some(target) = target else {
            return Err(CompileError {
                message: format!("Unknown function: {function_name}"),
                line: self.line,
            });
        };
        let expects_harness = matches!(
            peel_node(target),
            Node::FnDecl { params, .. }
                if params.first().is_some_and(|param| matches!(
                    param.type_expr.as_ref(),
                    Some(harn_parser::TypeExpr::Named(name)) if name == "Harness"
                ))
        );
        let function = self.string_constant(function_name);
        self.chunk.emit_u16(Op::GetVar, function, self.line);
        self.chunk.emit(Op::Return, self.line);
        ensure_chunk_addressable(&self.chunk, "the callable entry", self.line)?;
        Ok(CompiledCallableEntry {
            bootstrap: self.chunk,
            has_fixture: false,
            fixture_expects_harness: false,
            expects_harness,
        })
    }

    fn compile_entry_imports(&mut self, program: &[SNode]) -> Result<(), CompileError> {
        for node in program {
            if matches!(
                &node.node,
                Node::ImportDecl { .. }
                    | Node::SelectiveImport { .. }
                    | Node::NamespaceImport { .. }
            ) {
                self.compile_node(node)?;
            }
        }
        Ok(())
    }
}