geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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

mod custom;
mod function;

use super::super::{AnonymousFunctions, ModuleRole};
use super::declaration::HostedModuleDeclaration;
use crate::host::{RegisteredHostConstructions, RegisteredHostImplementationId};
use crate::plan::{HostFunctionTemplate, ModuleId, SourceContext};
use crate::planner::context::FunctionInfo;
use crate::planner::error::PlanError;
use ecow::EcoString;
use gleam_core::ast::TypedFunction;
use std::collections::{HashMap, HashSet};

pub(super) use custom::validate_host_custom_schemas;

pub(super) struct LinkedModule {
    pub(super) id: ModuleId,
    pub(super) package: EcoString,
    pub(super) module_name: EcoString,
    pub(super) source_context: Option<SourceContext>,
    pub(super) custom_types: Vec<crate::plan::CustomTypeDefinition>,
    pub(super) external_types: Vec<crate::plan::ExternalTypeDefinition>,
    pub(super) functions_by_name: HashMap<EcoString, FunctionInfo>,
    pub(super) functions: Vec<LinkedFunction>,
    pub(super) executable_externals: HashSet<EcoString>,
    pub(super) constants: Vec<gleam_core::ast::TypedModuleConstant>,
    pub(super) anonymous_functions: AnonymousFunctions,
}

pub(super) enum LinkedFunction {
    Gleam {
        info: FunctionInfo,
        function: TypedFunction,
    },
    ExternalFallback {
        name: EcoString,
        info: FunctionInfo,
        function: TypedFunction,
    },
    Host {
        template: HostFunctionTemplate,
        constructions: RegisteredHostConstructions,
        implementation: RegisteredHostImplementationId,
    },
}

pub(super) fn link_hosted_modules(
    root: ModuleId,
    declarations: Vec<HostedModuleDeclaration>,
) -> Result<Vec<LinkedModule>, PlanError> {
    let external_types = declarations
        .iter()
        .flat_map(|declaration| match declaration {
            HostedModuleDeclaration::Source { external_types, .. } => external_types.as_slice(),
            HostedModuleDeclaration::Host { .. } => &[],
        })
        .map(|definition| definition.name().clone())
        .collect::<HashSet<_>>();
    declarations
        .into_iter()
        .map(|declaration| link_hosted_module(root, declaration, &external_types))
        .collect()
}

fn link_hosted_module(
    root: ModuleId,
    declaration: HostedModuleDeclaration,
    external_types: &HashSet<crate::plan::ExternalTypeName>,
) -> Result<LinkedModule, PlanError> {
    match declaration {
        HostedModuleDeclaration::Source {
            id,
            package,
            module_name,
            source_context,
            custom_types,
            external_types: module_external_types,
            functions,
            constants,
            providers,
        } => {
            let role = if id == root {
                ModuleRole::Root
            } else {
                ModuleRole::Dependency
            };
            let functions = function::select_erlang_hosted_functions(functions, &providers);
            super::super::function_table_with_external_types(id, &functions, role, external_types)
                .and_then(|table| {
                    function::link_source_functions(
                        package.clone(),
                        module_name.clone(),
                        table.functions,
                        providers,
                    )
                    .map(|(functions, executable_externals)| LinkedModule {
                        id,
                        package,
                        module_name,
                        source_context,
                        custom_types,
                        external_types: module_external_types,
                        functions_by_name: table.by_name,
                        functions,
                        executable_externals,
                        constants,
                        anonymous_functions: table.anonymous_functions,
                    })
                })
        }
        HostedModuleDeclaration::Host {
            id,
            package,
            module_name,
            functions,
        } => Ok(function::link_source_less_module(
            id,
            package,
            module_name,
            functions,
        )),
    }
}