mirror of
https://github.com/fluencelabs/marine.git
synced 2025-06-11 22:11:27 +00:00
109 lines
3.6 KiB
Rust
109 lines
3.6 KiB
Rust
/*
|
|
* Copyright 2020 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.
|
|
*/
|
|
|
|
mod fn_instructions;
|
|
mod foreign_mod_instructions;
|
|
mod record_instructions;
|
|
mod utils;
|
|
|
|
use crate::Result;
|
|
|
|
use wasmer_wit::types::InterfaceType as IType;
|
|
use wasmer_wit::ast::Interfaces;
|
|
use wasmer_wit::types::RecordType;
|
|
|
|
#[derive(PartialEq, Debug, Default)]
|
|
pub(crate) struct WITResolver<'a> {
|
|
types: std::collections::HashMap<String, usize>,
|
|
pub(crate) interfaces: Interfaces<'a>,
|
|
not_resolved_types_count: usize,
|
|
}
|
|
|
|
impl<'a> WITResolver<'a> {
|
|
pub(crate) fn get_record_type_id(&self, record_name: &str) -> Result<usize> {
|
|
match self.types.get(record_name) {
|
|
Some(type_index) => Ok(*type_index),
|
|
None => Err(crate::errors::WITGeneratorError::CorruptedRecord(format!(
|
|
"Can't find record with name='{}', don't you forget to wrap it with #[fce]",
|
|
record_name
|
|
))),
|
|
}
|
|
}
|
|
|
|
// adds a stub for type with such a name if it wasn't found
|
|
pub(crate) fn get_record_type_id_unchecked(&mut self, record_name: &str) -> usize {
|
|
use wasmer_wit::ast::Type;
|
|
|
|
match self.types.get(record_name) {
|
|
Some(type_index) => *type_index,
|
|
None => {
|
|
self.types
|
|
.insert(record_name.to_string(), self.interfaces.types.len());
|
|
self.interfaces
|
|
.types
|
|
.push(Type::Record(RecordType::default()));
|
|
|
|
self.not_resolved_types_count += 1;
|
|
self.interfaces.types.len()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_record_type(
|
|
&self,
|
|
record_type_id: u64,
|
|
) -> Result<&wasmer_wit::types::RecordType> {
|
|
if record_type_id >= self.interfaces.types.len() as u64 {
|
|
return Err(crate::errors::WITGeneratorError::CorruptedRecord(format!(
|
|
"Can't find record with id {}, don't you forget to wrap it with #[fce]",
|
|
record_type_id
|
|
)));
|
|
}
|
|
|
|
match &self.interfaces.types[record_type_id as usize] {
|
|
wasmer_wit::ast::Type::Function { .. } => {
|
|
panic!("internal error inside WITResolver: interfaces AST type should be record not record")
|
|
}
|
|
wasmer_wit::ast::Type::Record(record_type) => Ok(record_type),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn insert_record_type(&mut self, record: RecordType) {
|
|
use wasmer_wit::ast::Type;
|
|
|
|
match self.types.get(&record.name) {
|
|
Some(pos) => {
|
|
self.interfaces.types[*pos] = Type::Record(record);
|
|
self.not_resolved_types_count -= 1;
|
|
}
|
|
None => {
|
|
self.types
|
|
.insert(record.name.clone(), self.interfaces.types.len());
|
|
|
|
self.interfaces.types.push(Type::Record(record));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn unresolved_types_count(&self) -> usize {
|
|
self.not_resolved_types_count
|
|
}
|
|
}
|
|
|
|
pub(crate) trait WITGenerator {
|
|
fn generate_wit<'a>(&'a self, wit_resolver: &mut WITResolver<'a>) -> Result<()>;
|
|
}
|