chore: cargo clippy

src/ir.rs

@@ -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() {

src/jit/helpers.rs

@@ -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()

src/jit/mod.rs

@@ -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)?;
 

src/stack.rs

@@ -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;

src/ty/internal/attrset.rs

@@ -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() {
+        self.data.iter().for_each(|(_, v)| if let Value::Thunk(ref thunk) = v.clone() {
-            Value::Thunk(ref thunk) => {
             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)?;

src/ty/internal/func.rs

@@ -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);

src/ty/internal/mod.rs

@@ -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)
     }

src/ty/internal/primop.rs

@@ -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!()

src/vm/env.rs

@@ -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 {

src/vm/test.rs

@@ -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(())
     })
 }