From 11729b1d4cecfff8df75b3fecda9c07093e59616 Mon Sep 17 00:00:00 2001 From: Ivan Enderlin Date: Mon, 10 Feb 2020 15:41:10 +0100 Subject: [PATCH] feat(interface-types) Rename `ImportedFunction` to `Import`. So that we are consistent with `Export`. --- src/decoders/binary.rs | 44 +++++++++++++++++------------------ src/encoders/wat.rs | 52 +++++++++++++++++++++--------------------- 2 files changed, 48 insertions(+), 48 deletions(-) diff --git a/src/decoders/binary.rs b/src/decoders/binary.rs index 9a1d77e..2853f7e 100644 --- a/src/decoders/binary.rs +++ b/src/decoders/binary.rs @@ -291,30 +291,30 @@ fn types<'input, E: ParseError<&'input [u8]>>( Ok((input, types)) } -fn imported_functions<'input, E: ParseError<&'input [u8]>>( +fn imports<'input, E: ParseError<&'input [u8]>>( input: &'input [u8], -) -> IResult<&'input [u8], Vec, E> { +) -> IResult<&'input [u8], Vec, E> { let mut input = input; - consume!((input, number_of_imported_functions) = leb(input)?); + consume!((input, number_of_imports) = leb(input)?); - let mut imported_functions = Vec::with_capacity(number_of_imported_functions as usize); + let mut imports = Vec::with_capacity(number_of_imports as usize); - for _ in 0..number_of_imported_functions { - consume!((input, imported_function_namespace) = string(input)?); - consume!((input, imported_function_name) = string(input)?); - consume!((input, imported_function_input_types) = list(input, ty)?); - consume!((input, imported_function_output_types) = list(input, ty)?); + for _ in 0..number_of_imports { + consume!((input, import_namespace) = string(input)?); + consume!((input, import_name) = string(input)?); + consume!((input, import_input_types) = list(input, ty)?); + consume!((input, import_output_types) = list(input, ty)?); - imported_functions.push(ImportedFunction { - namespace: imported_function_namespace, - name: imported_function_name, - input_types: imported_function_input_types, - output_types: imported_function_output_types, + imports.push(Import { + namespace: import_namespace, + name: import_name, + input_types: import_input_types, + output_types: import_output_types, }); } - Ok((input, imported_functions)) + Ok((input, imports)) } fn adapters<'input, E: ParseError<&'input [u8]>>( @@ -406,7 +406,7 @@ pub fn parse<'input, E: ParseError<&'input [u8]>>( consume!((input, exports) = exports(input)?); consume!((input, types) = types(input)?); - consume!((input, imported_functions) = imported_functions(input)?); + consume!((input, imports) = imports(input)?); consume!((input, adapters) = adapters(input)?); consume!((input, forwards) = forwards(input)?); @@ -415,7 +415,7 @@ pub fn parse<'input, E: ParseError<&'input [u8]>>( Interfaces { exports, types, - imported_functions, + imports, adapters, forwards, }, @@ -634,9 +634,9 @@ mod tests { } #[test] - fn test_imported_functions() { + fn test_imports() { let input = &[ - 0x02, // 2 imported functions + 0x02, // 2 imports 0x01, // string of 1 byte 0x61, // "a" 0x01, // string of 1 byte @@ -657,13 +657,13 @@ mod tests { let output = Ok(( &[] as &[u8], vec![ - ImportedFunction { + Import { namespace: "a", name: "b", input_types: vec![InterfaceType::I32], output_types: vec![InterfaceType::I64], }, - ImportedFunction { + Import { namespace: "c", name: "d", input_types: vec![InterfaceType::I32], @@ -672,7 +672,7 @@ mod tests { ], )); - assert_eq!(imported_functions::<()>(input), output); + assert_eq!(imports::<()>(input), output); } #[test] diff --git a/src/encoders/wat.rs b/src/encoders/wat.rs index fd1cd21..8768da7 100644 --- a/src/encoders/wat.rs +++ b/src/encoders/wat.rs @@ -1,5 +1,5 @@ use crate::{ - ast::{Adapter, Export, Forward, ImportedFunction, InterfaceType, Interfaces, Type}, + ast::{Adapter, Export, Forward, Import, InterfaceType, Interfaces, Type}, interpreter::Instruction, }; @@ -120,14 +120,14 @@ impl<'input> From<&Type<'input>> for String { } } -impl<'input> From<&ImportedFunction<'input>> for String { - fn from(imported_function: &ImportedFunction) -> Self { +impl<'input> From<&Import<'input>> for String { + fn from(import: &Import) -> Self { format!( r#"(@interface func ${namespace}_{name} (import "{namespace}" "{name}"){inputs}{outputs})"#, - namespace = imported_function.namespace, - name = imported_function.name, - inputs = input_types_to_param(&imported_function.input_types), - outputs = output_types_to_result(&imported_function.output_types), + namespace = import.namespace, + name = import.name, + inputs = input_types_to_param(&import.input_types), + outputs = output_types_to_result(&import.output_types), ) } } @@ -213,17 +213,17 @@ impl<'input> From<&Interfaces<'input>> for String { accumulator }); - let imported_functions = interfaces.imported_functions.iter().fold( - String::new(), - |mut accumulator, imported_function| { + let imports = interfaces + .imports + .iter() + .fold(String::new(), |mut accumulator, import| { accumulator.push_str(&format!( - "\n\n;; Interface, Imported function {}.{}\n", - imported_function.namespace, imported_function.name + "\n\n;; Interface, Import {}.{}\n", + import.namespace, import.name )); - accumulator.push_str(&String::from(imported_function)); + accumulator.push_str(&String::from(import)); accumulator - }, - ); + }); let adapters = interfaces @@ -260,7 +260,7 @@ impl<'input> From<&Interfaces<'input>> for String { output.push_str(&exports); output.push_str(&types); - output.push_str(&imported_functions); + output.push_str(&imports); output.push_str(&adapters); output.push_str(&forwards); @@ -389,30 +389,30 @@ mod tests { } #[test] - fn test_imported_functions() { + fn test_imports() { let inputs: Vec = vec![ - (&ImportedFunction { + (&Import { namespace: "ns", name: "foo", input_types: vec![InterfaceType::Int, InterfaceType::String], output_types: vec![InterfaceType::String], }) .into(), - (&ImportedFunction { + (&Import { namespace: "ns", name: "foo", input_types: vec![InterfaceType::String], output_types: vec![], }) .into(), - (&ImportedFunction { + (&Import { namespace: "ns", name: "foo", input_types: vec![], output_types: vec![InterfaceType::String], }) .into(), - (&ImportedFunction { + (&Import { namespace: "ns", name: "foo", input_types: vec![], @@ -549,14 +549,14 @@ mod tests { }, ], types: vec![], - imported_functions: vec![ - ImportedFunction { + imports: vec![ + Import { namespace: "ns", name: "foo", input_types: vec![], output_types: vec![InterfaceType::I32], }, - ImportedFunction { + Import { namespace: "ns", name: "bar", input_types: vec![], @@ -590,11 +590,11 @@ mod tests { ;; Interface, Export bar (@interface export "bar") -;; Interface, Imported function ns.foo +;; Interface, Import ns.foo (@interface func $ns_foo (import "ns" "foo") (result i32)) -;; Interface, Imported function ns.bar +;; Interface, Import ns.bar (@interface func $ns_bar (import "ns" "bar")) ;; Interface, Adapter ns.foo