imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

chore: cargo clippy

Browse Source
This commit is contained in:
imxyy_soope_
2025-05-20 18:39:09 +08:00
parent 736402dc53
commit 9b3c3d6fe9
10 changed files with 25 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/ir.rs
View File

@@ -716,7 +716,7 @@ fn downgrade_attr(attr: ast::Attr, ctx: &mut DowngradeContext) -> Result<Attr> {
Ident(ident) => Ok(Attr::Str(ctx.new_sym(ident.to_string()))),
Str(string) => {
let parts = string.normalized_parts();
if parts.len() == 0 {
if parts.is_empty() {
Ok(Attr::Str(ctx.new_sym("")))
} else if parts.len() == 1 {
match parts.into_iter().next().unwrap() {

4
src/jit/helpers.rs
View File

@@ -324,7 +324,7 @@ extern "C" fn helper_or(lhs: JITValue, rhs: JITValue) -> JITValue {
}
#[unsafe(no_mangle)]
extern "C" fn helper_call<'jit, 'vm>(
extern "C" fn helper_call<'jit>(
func: JITValue,
args: *mut JITValue,
arity: usize,
@@ -354,7 +354,7 @@ extern "C" fn helper_lookup<'jit, 'vm>(sym: usize, env: *const LetEnv<'jit, 'vm>
}
#[unsafe(no_mangle)]
extern "C" fn helper_force<'jit, 'vm>(thunk: JITValue, vm: *const VM<'jit>) -> JITValue {
extern "C" fn helper_force<'jit>(thunk: JITValue, vm: *const VM<'jit>) -> JITValue {
let mut val = Value::from(thunk);
val.force(unsafe { vm.as_ref() }.unwrap()).unwrap();
val.into()

11
src/jit/mod.rs
View File

@@ -1,7 +1,6 @@
use std::rc::Rc;
use inkwell::OptimizationLevel;
use inkwell::basic_block::BasicBlock;
use inkwell::builder::Builder;
use inkwell::context::Context;
use inkwell::execution_engine::{ExecutionEngine, JitFunction};
@@ -144,13 +143,13 @@ impl<'vm, 'ctx: 'vm> JITContext<'ctx> {
.add_function("nixjit_function", self.helpers.func_type, None);
let env = func_.get_nth_param(1).unwrap().into_pointer_value();
let entry = self.context.append_basic_block(func_, "entry");
self.builder.position_at_end(entry);
self.build_expr(
&mut iter,
vm,
env,
&mut stack,
func_,
entry,
func.opcodes.len(),
)?;
@@ -178,10 +177,8 @@ impl<'vm, 'ctx: 'vm> JITContext<'ctx> {
env: PointerValue<'ctx>,
stack: &mut Stack<BasicValueEnum<'ctx>, CAP>,
func: FunctionValue<'ctx>,
bb: BasicBlock<'ctx>,
mut length: usize,
) -> Result<usize> {
self.builder.position_at_end(bb);
while length > 1 {
let opcode = iter.next().unwrap();
let br = self.single_op(opcode, vm, env, stack)?;
@@ -215,12 +212,14 @@ impl<'vm, 'ctx: 'vm> JITContext<'ctx> {
)?;
length -= br;
let br = self.build_expr(iter, vm, env, stack, func, consq, br)?;
self.builder.position_at_end(consq);
let br = self.build_expr(iter, vm, env, stack, func, br)?;
self.builder.build_store(result, stack.pop())?;
self.builder.build_unconditional_branch(cont)?;
length -= br;
self.build_expr(iter, vm, env, stack, func, alter, br)?;
self.builder.position_at_end(alter);
self.build_expr(iter, vm, env, stack, func, br)?;
self.builder.build_store(result, stack.pop())?;
self.builder.build_unconditional_branch(cont)?;

2
src/stack.rs
View File

@@ -37,7 +37,7 @@ impl<T, const CAP: usize> Stack<T, CAP> {
.get_mut(self.top)
.map_or_else(
|| Err(Error::EvalError("stack overflow".to_string())),
|ok| Ok(ok),
Ok,
)?
.write(item);
self.top += 1;

11
src/ty/internal/attrset.rs
View File

@@ -53,17 +53,14 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
}
pub fn capture(&mut self, env: &Rc<LetEnv<'jit, 'vm>>) {
self.data.iter().for_each(|(_, v)| match v.clone() {
Value::Thunk(ref thunk) => {
thunk.capture(env.clone());
}
_ => (),
self.data.iter().for_each(|(_, v)| if let Value::Thunk(ref thunk) = v.clone() {
thunk.capture(env.clone());
})
}
pub fn update(&mut self, other: &AttrSet<'jit, 'vm>) {
for (k, v) in other.data.iter() {
self.push_attr_force(k.clone(), v.clone())
self.push_attr_force(*k, v.clone())
}
}
@@ -79,7 +76,7 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
let mut map: Vec<_> = self
.data
.iter()
.map(|(k, v)| (k.clone(), v.clone()))
.map(|(k, v)| (*k, v.clone()))
.collect();
for (_, v) in map.iter_mut() {
v.force_deep(vm)?;

8
src/ty/internal/func.rs
View File

@@ -56,7 +56,7 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
use Param::*;
let env = match self.func.param.clone() {
Ident(ident) => self.env.clone().enter_arg(ident.into(), arg),
Ident(ident) => self.env.clone().enter_arg(ident, arg),
Formals {
formals,
ellipsis,
@@ -75,7 +75,6 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
todo!()
}
for (formal, default) in formals {
let formal = formal.clone().into();
let arg = arg
.select(formal)
.or_else(|| {
@@ -85,12 +84,11 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
new.insert(formal, arg);
}
if let Some(alias) = alias {
new.insert(alias.clone().into(), Value::AttrSet(arg));
new.insert(alias, Value::AttrSet(arg));
}
self.env.clone().enter_attrs(AttrSet::new(new).into())
}
}
.into();
};
let count = self.count.get();
self.count.replace(count + 1);

4
src/ty/internal/mod.rs
View File

@@ -459,7 +459,7 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
AttrSet(attrs) => attrs.to_public(vm, seen),
List(list) => list.to_public(vm, seen),
Catchable(catchable) => Value::Catchable(catchable.clone()),
Const(cnst) => Value::Const(cnst.clone().into()),
Const(cnst) => Value::Const(cnst.clone()),
Thunk(_) => Value::Thunk,
ThunkRef(_) => Value::Thunk,
PrimOp(primop) => Value::PrimOp(primop.name),
@@ -514,7 +514,7 @@ impl<'jit, 'vm> Thunk<'jit, 'vm> {
let value = vm.eval(opcodes.iter().copied(), env.get().unwrap().clone())?;
let _ = std::mem::replace(
&mut *self.thunk.borrow_mut(),
_Thunk::Value(value.clone().into()),
_Thunk::Value(value.clone()),
);
Ok(value)
}

2
src/ty/internal/primop.rs
View File

@@ -69,7 +69,7 @@ impl<'jit: 'vm, 'vm> PartialPrimOp<'jit, 'vm> {
if self_mut.arity > 0 {
Value::PartialPrimOp(self_clone).ok()
} else if self_mut.arity == 0 {
let args = std::mem::replace(&mut self_mut.args, Vec::new());
let args = std::mem::take(&mut self_mut.args);
(self.func)(vm, args)
} else {
unimplemented!()

6
src/vm/env.rs
View File

@@ -51,7 +51,7 @@ impl<'jit, 'vm> LetEnv<'jit, 'vm> {
}
}
}
self.last.as_ref().map(|env| env.lookup(symbol)).flatten()
self.last.as_ref().and_then(|env| env.lookup(symbol))
}
pub fn enter_arg(self: Rc<Self>, ident: usize, val: Value<'jit, 'vm>) -> Rc<Self> {
@@ -82,7 +82,7 @@ impl<'jit, 'vm> LetEnv<'jit, 'vm> {
})
.collect::<HashMap<_, _>>();
let map = Env::Let(AttrSet::new(map).into());
let last = Some(self.into());
let last = Some(self);
LetEnv { last, map }.into()
}
@@ -96,7 +96,7 @@ impl<'jit, 'vm> WithEnv<'jit, 'vm> {
if let Some(val) = self.map.select(symbol) {
return Some(val);
}
self.last.as_ref().map(|env| env.lookup(symbol)).flatten()
self.last.as_ref().and_then(|env| env.lookup(symbol))
}
pub fn enter_with(self, new: Rc<AttrSet<'jit, 'vm>>) -> Self {

5
src/vm/test.rs
View File

@@ -227,9 +227,10 @@ fn test_fib() {
#[bench]
fn bench_fib(b: &mut Bencher) {
b.iter(|| {
black_box(test_expr(
test_expr(
"let fib = n: if n == 1 || n == 2 then 1 else (fib (n - 1)) + (fib (n - 2)); in fib 20",
int!(6765),
))
);
black_box(())
})
}