Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

chore: Fix clippy lints in API crate #4386

Merged
merged 1 commit into from
Jan 6, 2024
+68 −67
Merged

chore: Fix clippy lints in API crate #4386

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 8 additions & 6 deletions lib/api/src/sys/instance.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,13 +16,15 @@ pub struct Instance {
mod send_test {
use super::*;

fn is_send<T: Send>() -> bool {
true
}
// Only here to statically ensure that `Instance` is `Send`.
// Will fail to compile otherwise.
#[allow(dead_code)]
fn instance_is_send(inst: Instance) {
fn is_send(t: impl Send) {
let _ = t;
}

#[test]
fn instance_is_send() {
assert!(is_send::<Instance>());
is_send(inst);
}
}

Expand Down
62 changes: 31 additions & 31 deletions lib/api/tests/externals.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@ fn global_new() -> Result<(), String> {
let mut store = Store::default();
let global = Global::new(&mut store, Value::I32(10));
assert_eq!(
global.ty(&mut store),
global.ty(&store),
GlobalType {
ty: Type::I32,
mutability: Mutability::Const
Expand All @@ -18,7 +18,7 @@ fn global_new() -> Result<(), String> {

let global_mut = Global::new_mut(&mut store, Value::I32(10));
assert_eq!(
global_mut.ty(&mut store),
global_mut.ty(&store),
GlobalType {
ty: Type::I32,
mutability: Mutability::Var
Expand Down Expand Up @@ -86,7 +86,7 @@ fn table_new() -> Result<(), String> {
let f = Function::new_typed(&mut store, || {});
let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f)))
.map_err(|e| format!("{e:?}"))?;
assert_eq!(table.ty(&mut store), table_type);
assert_eq!(table.ty(&store), table_type);

// Anyrefs not yet supported
// let table_type = TableType {
Expand Down Expand Up @@ -170,8 +170,8 @@ fn memory_new() -> Result<(), String> {
maximum: Some(Pages(10)),
};
let memory = Memory::new(&mut store, memory_type).map_err(|e| format!("{e:?}"))?;
assert_eq!(memory.view(&mut store).size(), Pages(0));
assert_eq!(memory.ty(&mut store), memory_type);
assert_eq!(memory.view(&store).size(), Pages(0));
assert_eq!(memory.ty(&store), memory_type);
Ok(())
}

Expand All @@ -180,11 +180,11 @@ fn memory_grow() -> Result<(), String> {
let mut store = Store::default();
let desc = MemoryType::new(Pages(10), Some(Pages(16)), false);
let memory = Memory::new(&mut store, desc).map_err(|e| format!("{e:?}"))?;
assert_eq!(memory.view(&mut store).size(), Pages(10));
assert_eq!(memory.view(&store).size(), Pages(10));

let result = memory.grow(&mut store, Pages(2)).unwrap();
assert_eq!(result, Pages(10));
assert_eq!(memory.view(&mut store).size(), Pages(12));
assert_eq!(memory.view(&store).size(), Pages(12));

let result = memory.grow(&mut store, Pages(10));
assert_eq!(
Expand All @@ -210,25 +210,25 @@ fn memory_grow() -> Result<(), String> {
fn function_new() -> Result<(), String> {
let mut store = Store::default();
let function = Function::new_typed(&mut store, || {});
assert_eq!(function.ty(&mut store), FunctionType::new(vec![], vec![]));
assert_eq!(function.ty(&store), FunctionType::new(vec![], vec![]));
let function = Function::new_typed(&mut store, |_a: i32| {});
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![Type::I32], vec![])
);
let function = Function::new_typed(&mut store, |_a: i32, _b: i64, _c: f32, _d: f64| {});
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
);
let function = Function::new_typed(&mut store, || -> i32 { 1 });
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![], vec![Type::I32])
);
let function = Function::new_typed(&mut store, || -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) });
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
);
Ok(())
Expand All @@ -243,11 +243,11 @@ fn function_new_env() -> Result<(), String> {
let my_env = MyEnv {};
let env = FunctionEnv::new(&mut store, my_env);
let function = Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>| {});
assert_eq!(function.ty(&mut store), FunctionType::new(vec![], vec![]));
assert_eq!(function.ty(&store), FunctionType::new(vec![], vec![]));
let function =
Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>, _a: i32| {});
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![Type::I32], vec![])
);
let function = Function::new_typed_with_env(
Expand All @@ -256,13 +256,13 @@ fn function_new_env() -> Result<(), String> {
|_env: FunctionEnvMut<MyEnv>, _a: i32, _b: i64, _c: f32, _d: f64| {},
);
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
);
let function =
Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>| -> i32 { 1 });
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![], vec![Type::I32])
);
let function = Function::new_typed_with_env(
Expand All @@ -271,7 +271,7 @@ fn function_new_env() -> Result<(), String> {
|_env: FunctionEnvMut<MyEnv>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
);
assert_eq!(
function.ty(&mut store),
function.ty(&store),
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
);
Ok(())
Expand All @@ -288,35 +288,35 @@ fn function_new_dynamic() -> Result<(), String> {
&function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![Type::I32], vec![]);
let function = Function::new(
&mut store,
&function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
let function = Function::new(
&mut store,
&function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32]);
let function = Function::new(
&mut store,
&function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
let function = Function::new(
&mut store,
&function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);

// Using array signature
let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
Expand All @@ -325,9 +325,9 @@ fn function_new_dynamic() -> Result<(), String> {
function_type,
|_values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store).params(), [Type::V128]);
assert_eq!(function.ty(&store).params(), [Type::V128]);
assert_eq!(
function.ty(&mut store).results(),
function.ty(&store).results(),
[Type::I32, Type::F32, Type::F64]
);

Expand All @@ -350,39 +350,39 @@ fn function_new_dynamic_env() -> Result<(), String> {
&function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![Type::I32], vec![]);
let function = Function::new_with_env(
&mut store,
&env,
&function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
let function = Function::new_with_env(
&mut store,
&env,
&function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32]);
let function = Function::new_with_env(
&mut store,
&env,
&function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
let function = Function::new_with_env(
&mut store,
&env,
&function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store), function_type);
assert_eq!(function.ty(&store), function_type);

// Using array signature
let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
Expand All @@ -392,9 +392,9 @@ fn function_new_dynamic_env() -> Result<(), String> {
function_type,
|_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut store).params(), [Type::V128]);
assert_eq!(function.ty(&store).params(), [Type::V128]);
assert_eq!(
function.ty(&mut store).results(),
function.ty(&store).results(),
[Type::I32, Type::F32, Type::F64]
);

Expand Down
2 changes: 1 addition & 1 deletion lib/api/tests/function_env.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,7 @@ fn data_and_store_mut() -> Result<(), String> {
let (mut data, mut storemut) = envmut.data_and_store_mut();

assert_eq!(
data.global.ty(&mut storemut),
data.global.ty(&storemut),
GlobalType {
ty: Type::I32,
mutability: Mutability::Var
Expand Down
5 changes: 2 additions & 3 deletions lib/api/tests/import_function.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,8 +109,7 @@ fn calling_function_exports() -> Result<()> {
};
let instance = Instance::new(&mut store, &module, &imports)?;

let add: TypedFunction<(i32, i32), i32> =
instance.exports.get_typed_function(&mut store, "add")?;
let add: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;

let result = add.call(&mut store, 10, 20)?;
assert_eq!(result, 30);
Expand Down Expand Up @@ -145,7 +144,7 @@ fn back_and_forth_with_imports() -> Result<()> {
let instance = Instance::new(&mut store, &module, &import_object)?;

let add_one: TypedFunction<i32, i32> =
instance.exports.get_typed_function(&mut store, "add_one")?;
instance.exports.get_typed_function(&store, "add_one")?;
add_one.call(&mut store, 1)?;

Ok(())
Expand Down
16 changes: 8 additions & 8 deletions lib/api/tests/module.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -233,35 +233,35 @@ fn calling_host_functions_with_negative_values_works() -> Result<(), String> {

let f1: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func1")
.get_typed_function(&store, "call_host_func1")
.map_err(|e| format!("{e:?}"))?;
let f2: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func2")
.get_typed_function(&store, "call_host_func2")
.map_err(|e| format!("{e:?}"))?;
let f3: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func3")
.get_typed_function(&store, "call_host_func3")
.map_err(|e| format!("{e:?}"))?;
let f4: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func4")
.get_typed_function(&store, "call_host_func4")
.map_err(|e| format!("{e:?}"))?;
let f5: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func5")
.get_typed_function(&store, "call_host_func5")
.map_err(|e| format!("{e:?}"))?;
let f6: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func6")
.get_typed_function(&store, "call_host_func6")
.map_err(|e| format!("{e:?}"))?;
let f7: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func7")
.get_typed_function(&store, "call_host_func7")
.map_err(|e| format!("{e:?}"))?;
let f8: TypedFunction<(), ()> = instance
.exports
.get_typed_function(&mut store, "call_host_func8")
.get_typed_function(&store, "call_host_func8")
.map_err(|e| format!("{e:?}"))?;

f1.call(&mut store).map_err(|e| format!("{e:?}"))?;
Expand Down
Loading
Loading