chore: apply clippy --fix

Author: yannham

core/src/bytecode/ast/compat.rs

@@ -7,12 +7,12 @@
 use super::{primop::PrimOp, *};
 use crate::{
     bytecode::value::{
-        ArrayData, Container, EnumVariantData, InlineValue, NickelValue, TypeData, ValueContentRef,
+        ArrayData, Container, EnumVariantData, NickelValue, TypeData, ValueContentRef,
         ValueContentRefMut,
     },
     combine::Combine,
     label,
-    position::{PosIdx, PosTable, RawSpan},
+    position::{PosTable, RawSpan},
     term, typ as mline_type,
 };
 use indexmap::IndexMap;

core/src/bytecode/value/lens.rs

@@ -271,7 +271,7 @@ impl TermContent {
         };
 
         // unwrap(): if the lens is a TermContent, then the underlying value must be a term block.
-        &value.as_term().unwrap()
+        value.as_term().unwrap()
     }
 
     /// Unconditionally take the inner `Term` out, ignoring the actual shape of the content.

core/src/bytecode/value/mod.rs

@@ -612,7 +612,7 @@ impl NickelValue {
     /// block with an enum variant inside, which has no arguments, or `None` otherwise.
     pub fn as_enum_tag(&self) -> Option<LocIdent> {
         let enum_var = self.as_enum_variant()?;
-        enum_var.arg.is_none().then(|| enum_var.tag)
+        enum_var.arg.is_none().then_some(enum_var.tag)
     }
 
     /// Returns a reference to the inner sealing key stored in this value if `self` is a value
@@ -1205,7 +1205,7 @@ impl NickelValue {
                 ValueBlockRc::header_from_raw(NonNull::new_unchecked(self.data as *mut u8)).pos_idx
             },
             // unwrap(): if the tag is `Inline`, then `inline_pos_idx()` must be `Some`
-            ValueTag::Inline => self.inline_pos_idx().unwrap().into(),
+            ValueTag::Inline => self.inline_pos_idx().unwrap(),
         }
     }
 
@@ -1939,10 +1939,10 @@ impl ValueBlockRc {
                 Self::encode(self.decode::<EnumVariantData>().clone(), self.pos_idx())
             }
             DataTag::ForeignId => {
-                Self::encode(self.decode::<ForeignIdData>().clone(), self.pos_idx())
+                Self::encode(*self.decode::<ForeignIdData>(), self.pos_idx())
             }
             DataTag::SealingKey => {
-                Self::encode(self.decode::<SealingKeyData>().clone(), self.pos_idx())
+                Self::encode(*self.decode::<SealingKeyData>(), self.pos_idx())
             }
             DataTag::CustomContract => {
                 Self::encode(self.decode::<CustomContractData>().clone(), self.pos_idx())
@@ -2244,16 +2244,14 @@ impl Container<&ArrayData> {
     pub fn iter(&self) -> impl Iterator<Item = &NickelValue> {
         self.into_opt()
             .into_iter()
-            .map(|array_data| array_data.array.iter())
-            .flatten()
+            .flat_map(|array_data| array_data.array.iter())
     }
 
     /// Iterates over the pending contracts.
     pub fn iter_pending_contracts(&self) -> impl Iterator<Item = &RuntimeContract> {
         self.into_opt()
             .into_iter()
-            .map(|array_data| array_data.pending_contracts.iter())
-            .flatten()
+            .flat_map(|array_data| array_data.pending_contracts.iter())
     }
 
     /// Retrieves an element from the underlying array at the given index, or returns `None` if `self`

core/src/cache.rs

@@ -16,7 +16,6 @@ use crate::{
     },
     closurize::Closurize as _,
     error::{Error, ImportError, ParseError, ParseErrors, TypecheckError},
-    eval::Closure,
     eval::cache::Cache as EvalCache,
     files::{FileId, Files},
     identifier::LocIdent,
@@ -26,10 +25,10 @@ use crate::{
     position::{PosTable, TermPos},
     program::FieldPath,
     stdlib::{self as nickel_stdlib, StdlibModule},
-    term::{self, Term},
+    term::{self},
     transform::{Wildcards, import_resolution},
     traverse::{Traverse, TraverseOrder},
-    typ::{self as mainline_typ, UnboundTypeVariableError},
+    typ::UnboundTypeVariableError,
     typecheck::{self, HasApparentType, TypecheckMode, typecheck},
     {eval, parser, transform},
 };
@@ -612,7 +611,7 @@ impl SourceCache {
                     .map(|v| v.with_pos_idx(pos_idx))
                     .map_err(|err| ParseError::from_serde_json(err, file_id, &self.files))
             }
-            InputFormat::Text => Ok(NickelValue::string(source, pos_idx).into()),
+            InputFormat::Text => Ok(NickelValue::string(source, pos_idx)),
         }
     }
 
@@ -2922,15 +2921,15 @@ mod ast_cache {
                 let ast = term.to_ast(slf.alloc, pos_table);
                 let mut resolver = AstResolver::new(slf.alloc, slf.asts, slice.reborrow());
 
-                let ret = typecheck::env_add_term(
+                
+                typecheck::env_add_term(
                     slf.alloc,
                     &mut slf.type_ctxt.type_env,
                     ast,
                     &slf.type_ctxt.term_env,
                     &mut resolver,
                 )
-                .map_err(|_| NotARecord);
-                ret
+                .map_err(|_| NotARecord)
             })
         }
     }

core/src/error/mod.rs

@@ -1496,7 +1496,7 @@ impl IntoDiagnostics for EvalError {
                             notes.push("Values of different types can't be merged".to_owned());
                         }
                         "String" | "Number" | "Bool" | "Array" | "EnumTag" => {
-                            push_merge_note(&mut notes, &left_ty);
+                            push_merge_note(&mut notes, left_ty);
                         }
                         "Function" | "MatchExpression" => {
                             notes.push(
@@ -1945,7 +1945,7 @@ mod blame_error {
                 (TermPos::Inherited(ref val_pos), Some(arg_pos)) if val_pos == arg_pos => {
                     evaluated_arg = evaluated_arg.with_pos_idx(PosIdx::NONE);
                     labels.push(
-                        secondary_term(&pos_table, &evaluated_arg, files)
+                        secondary_term(pos_table, &evaluated_arg, files)
                             .with_message("evaluated to this value"),
                     );
                 }
@@ -1959,12 +1959,12 @@ mod blame_error {
 
                     evaluated_arg = evaluated_arg.with_pos_idx(PosIdx::NONE);
                     labels.push(
-                        secondary_term(&pos_table, &evaluated_arg, files)
+                        secondary_term(pos_table, &evaluated_arg, files)
                             .with_message("evaluated to this value"),
                     );
                 }
                 (TermPos::None, _) => labels.push(
-                    secondary_term(&pos_table, &evaluated_arg, files)
+                    secondary_term(pos_table, &evaluated_arg, files)
                         .with_message("evaluated to this value"),
                 ),
             }

core/src/eval/contract_eq.rs

@@ -123,7 +123,7 @@ fn contract_eq_bounded(
     // Test for physical equality as both an optimization and a way to cheaply equate complex
     // contracts that happen to point to the same definition (while the purposely limited
     // structural checks below may reject the equality)
-    if t1.phys_eq(&t2) && Environment::ptr_eq(env1, env2) {
+    if t1.phys_eq(t2) && Environment::ptr_eq(env1, env2) {
         return true;
     }
 

core/src/eval/fixpoint.rs

@@ -1,8 +1,6 @@
 //! Compute the fixpoint of a recursive record.
 use super::{merge::RevertClosurize, *};
-use crate::{
-    position::{PosIdx, PosTable, TermPos},
-};
+use crate::position::PosIdx;
 
 /// Updates the environment of an expression by extending it with a recursive environment. In the
 /// general case, the expression is expected to be a variable pointing to the element to be patched.

core/src/eval/mod.rs

@@ -76,7 +76,7 @@
 use crate::{
     bytecode::value::{
         Container, EnumVariantData, NickelValue, ValueContent,
-        ValueContentRef, ValueContentRefMut, lens::TermContent,
+        ValueContentRef, ValueContentRefMut,
     },
     cache::{CacheHub as ImportCaches, ImportResolver},
     closurize::{Closurize, closurize_rec_record},
@@ -85,7 +85,7 @@ use crate::{
     files::{FileId, Files},
     identifier::{Ident, LocIdent},
     metrics::{increment, measure_runtime},
-    position::{PosIdx, PosTable, TermPos},
+    position::{PosIdx, PosTable},
     program::FieldPath,
     term::{
         BinaryOp, BindingType, Import, LetAttrs, MatchBranch, MatchData, RecordOpKind,
@@ -823,7 +823,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                 ValueContentRef::Term(Term::OpN(op, args)) => {
                     // Arguments are passed as a stack to the operation continuation, so we reverse
                     // the original list.
-                    let mut args_iter = args.into_iter();
+                    let mut args_iter = args.iter();
                     let fst_arg = args_iter.next().ok_or_else(|| {
                         EvalErrorData::NotEnoughArgs(op.arity(), op.to_string(), pos_idx)
                     })?;
@@ -1518,7 +1518,6 @@ pub fn subst<C: Cache>(
             };
 
             let array = array_data.array.into_iter()
-                .into_iter()
                 .map(|t| subst(pos_table, cache, t, initial_env, env))
                 .collect();
 

core/src/eval/operation.rs

@@ -20,19 +20,19 @@ use crate::nix_ffi;
 
 use crate::{
     bytecode::value::{
-        Array, ArrayData, Container, EnumVariantData, InlineValue, NickelValue, TypeData,
+        Array, ArrayData, Container, EnumVariantData, NickelValue, TypeData,
         ValueContent, ValueContentRef, ValueContentRefMut,
     },
     cache::InputFormat,
     closurize::Closurize,
     combine::Combine,
-    error::{EvalCtxt, EvalError, EvalErrorData, IllegalPolymorphicTailAction, Warning},
+    error::{EvalErrorData, IllegalPolymorphicTailAction, Warning},
     identifier::LocIdent,
     label::{Polarity, TypeVarData, ty_path},
     metrics::increment,
     mk_app, mk_fun, mk_record,
     parser::utils::parse_number_sci,
-    position::{PosIdx, PosTable, TermPos},
+    position::{PosIdx, PosTable},
     serialize::{self, ExportFormat},
     stdlib::internals,
     term::{make as mk_term, record::*, string::NickelString, *},
@@ -102,7 +102,7 @@ pub enum OperationCont {
 
 /// A string represention of the type of the first argument of serialization-related primitive
 /// operations. This is a Nickel enum of the supported serialization formats.
-static ENUM_FORMAT: &'static str = "[| 'Json, 'Yaml, 'Toml |]";
+static ENUM_FORMAT: &str = "[| 'Json, 'Yaml, 'Toml |]";
 
 impl std::fmt::Debug for OperationCont {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -315,7 +315,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
             //     _ => mk_type_error!("Label"),
             // }),
             UnaryOp::EnumEmbed(_id) => {
-                if let Some(_) = value.as_enum_variant() {
+                if value.as_enum_variant().is_some() {
                     Ok(value.with_pos_idx(pos_op_inh).into())
                 } else {
                     mk_type_error!("Enum")
@@ -729,13 +729,13 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                     ValueContentRef::Array(Container::Alloc(array_data)) => {
                         let terms = seq_terms(
                             array_data.array.iter().map(|t| {
-                                let t_with_ctr = RuntimeContract::apply_all(
+                                
+                                RuntimeContract::apply_all(
                                     t.clone(),
                                     array_data.pending_contracts.iter().cloned(),
                                     pos.to_inherited(&mut self.context.pos_table),
                                 )
-                                .closurize(&mut self.context.cache, env.clone());
-                                t_with_ctr
+                                .closurize(&mut self.context.cache, env.clone())
                             }),
                             pos_op,
                         );
@@ -1130,7 +1130,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                             })
                         } else {
                             Ok(Closure {
-                                value: NickelValue::enum_tag(tag, pos_op_inh).into(),
+                                value: NickelValue::enum_tag(tag, pos_op_inh),
                                 env,
                             })
                         }
@@ -1237,7 +1237,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
             }
             UnaryOp::Trace => {
                 if let Some(s) = value.as_string() {
-                    let _ = writeln!(self.context.trace, "std.trace: {}", s);
+                    let _ = writeln!(self.context.trace, "std.trace: {s}");
                     Ok(())
                 } else {
                     mk_type_error!("String")
@@ -1312,7 +1312,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                 let arg = NickelValue::thunk(Thunk::new(arg_clos), arg_pos);
 
                 Ok(NickelValue::enum_variant(
-                    LocIdent::new(&tag).with_pos(self.context.pos_table.get(pos)),
+                    LocIdent::new(tag).with_pos(self.context.pos_table.get(pos)),
                     Some(arg),
                     pos_op_inh,
                 )
@@ -1327,7 +1327,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
             UnaryOp::EnumIsVariant => Ok(NickelValue::bool_value(
                 value
                     .as_enum_variant()
-                    .map_or(false, |enum_variant| enum_variant.arg.is_some()),
+                    .is_some_and(|enum_variant| enum_variant.arg.is_some()),
                 pos_op_inh,
             )
             .into()),
@@ -1452,7 +1452,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                 }
                 // The stack should already contain the default label to attach, so push
                 // the (potential) error data.
-                self.stack.push_arg(Closure { value: value, env }, pos_arg);
+                self.stack.push_arg(Closure { value, env }, pos_arg);
 
                 Ok(Closure {
                     value: internals::add_default_check_label(),
@@ -1770,7 +1770,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                     return mk_type_error!("String", 2, value2);
                 };
 
-                Ok(NickelValue::string(format!("{}{}", s1, s2), pos_op_inh).into())
+                Ok(NickelValue::string(format!("{s1}{s2}"), pos_op_inh).into())
             }
             BinaryOp::ContractApply | BinaryOp::ContractCheck => {
                 // Performing only one match `if let Term::Type` and putting the call to
@@ -2340,7 +2340,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                     )
                 {
                     match record.sealed_tail.as_ref() {
-                        Some(t) if t.has_dyn_field(&id) => {
+                        Some(t) if t.has_dyn_field(id) => {
                             Err(EvalErrorData::IllegalPolymorphicTailAccess {
                                 action: IllegalPolymorphicTailAction::FieldRemove {
                                     field: id.to_string(),
@@ -2948,19 +2948,19 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                         fields: IndexMap::from([
                             (
                                 LocIdent::from("left_only"),
-                                Field::from(NickelValue::from(left_only)),
+                                Field::from(left_only),
                             ),
                             (
                                 LocIdent::from("left_center"),
-                                Field::from(NickelValue::from(left_center)),
+                                Field::from(left_center),
                             ),
                             (
                                 LocIdent::from("right_center"),
-                                Field::from(NickelValue::from(right_center)),
+                                Field::from(right_center),
                             ),
                             (
                                 LocIdent::from("right_only"),
-                                Field::from(NickelValue::from(right_only)),
+                                Field::from(right_only),
                             ),
                         ]),
                         attrs: RecordAttrs::default(),
@@ -3180,7 +3180,7 @@ impl<'ctxt, R: ImportResolver, C: Cache> VirtualMachine<'ctxt, R, C> {
                     expected: expected.to_owned(),
                     arg_number,
                     pos_arg,
-                    arg_evaluated: arg_evaluated,
+                    arg_evaluated,
                     pos_op,
                 })
             };

core/src/eval/stack.rs

@@ -351,7 +351,7 @@ impl<C: Cache> std::fmt::Debug for Stack<C> {
 mod tests {
     use super::*;
     use crate::eval::cache::CacheImpl;
-    use crate::term::{Term, UnaryOp};
+    use crate::term::UnaryOp;
     use assert_matches::assert_matches;
 
     impl Stack<CacheImpl> {