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

/*
 * Copyright 2023 Fluence Labs Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

pub mod errors;
pub mod exports;
pub mod imports;
pub mod store;
pub mod wasi;
pub mod wtype;
pub mod module;
pub mod instance;
pub mod caller;
pub mod function;
pub mod macros;

/// Helper functions for backend implementations.
pub mod impl_utils;

pub mod prelude {
    pub use crate::errors::*;
    pub use crate::exports::*;
    pub use crate::imports::*;
    pub use crate::store::*;
    pub use crate::wasi::*;
    pub use crate::wtype::*;
    pub use crate::module::*;
    pub use crate::instance::*;
    pub use crate::caller::*;
    pub use crate::function::*;
    pub use crate::WasmBackend;
    pub use crate::DelayedContextLifetime;
}

pub use prelude::*;

pub use macros::*;

use it_memory_traits::MemoryView;

use std::marker::PhantomData;

/// A core trait for any backend. It serves two purposes:
/// * handles initialization of the library if needed
/// * provides access to all public types -- like `mod` but for trait impls.
pub trait WasmBackend: Clone + Default + 'static {
    /// A type that stores all the data, while most of the types are handles to data from `Store`.
    type Store: Store<Self>;
    /// A compiled, but not instantiated module.
    type Module: Module<Self>;
    /// An object that holds all the functions that are given to `Module` as imports.
    type Imports: Imports<Self>; // maybe rename to Linker?
    /// An instantiated module ready to be executed.
    type Instance: Instance<Self>;
    /// A temporary immutable handle to `Store`.
    type Context<'c>: Context<Self>;
    /// A temporary mutable handle to `Store`
    type ContextMut<'c>: ContextMut<Self>;
    /// A type that is used to pass context to imports.
    type ImportCallContext<'c>: ImportCallContext<Self>;
    /// A host function prepared to be used as import for instantiating a module, contained in `Store`.
    type HostFunction: HostFunction<Self> + FuncConstructor<Self>;
    /// An export function from a wasm instance, contained in `Store`
    type ExportFunction: ExportFunction<Self>;
    /// A wasm memory.
    type Memory: Memory<Self>;
    /// A view to the wasm memory.
    type MemoryView: MemoryView<DelayedContextLifetime<Self>>;

    /// Type that provides all WASI-related APIs.
    type Wasi: WasiImplementation<Self>;

    /// Creates a new wasm backend with default configuration. In future, a configuration
    /// may be passed as argument.
    fn new() -> WasmBackendResult<Self>;
}

/// This struct is a helper, that allows passing `<WB as WasmBackend>::ContextMut` as template parameter,
/// but not specify a lifetime. Any local lifetime can be used instead.
pub struct DelayedContextLifetime<WB: WasmBackend> {
    _data: PhantomData<WB>,
}

impl<WB: WasmBackend> it_memory_traits::Store for DelayedContextLifetime<WB> {
    type ActualStore<'c> = <WB as WasmBackend>::ContextMut<'c>;
}