diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index 83cf240815..4be5785f3d 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -37,4 +37,4 @@ jobs: uses: actions-rs/clippy-check@v1 with: token: ${{ secrets.GITHUB_TOKEN }} - args: -p libstackerdb -p stacks-signer -p pox-locking --no-deps --tests --all-features -- -D warnings \ No newline at end of file + args: -p libstackerdb -p stacks-signer -p pox-locking -p clarity -p libsigner --no-deps --tests --all-features -- -D warnings \ No newline at end of file diff --git a/clarity/src/vm/analysis/analysis_db.rs b/clarity/src/vm/analysis/analysis_db.rs index 1bef2834a8..36e1f8c970 100644 --- a/clarity/src/vm/analysis/analysis_db.rs +++ b/clarity/src/vm/analysis/analysis_db.rs @@ -50,11 +50,11 @@ impl<'a> AnalysisDatabase<'a> { self.begin(); let result = f(self).or_else(|e| { self.roll_back() - .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?; + .map_err(|e| CheckErrors::Expects(format!("{e:?}")))?; Err(e) })?; self.commit() - .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?; + .map_err(|e| CheckErrors::Expects(format!("{e:?}")))?; Ok(result) } @@ -130,9 +130,9 @@ impl<'a> AnalysisDatabase<'a> { .map_err(|_| CheckErrors::Expects("Bad data deserialized from DB".into())) }) .transpose()? - .and_then(|mut x| { + .map(|mut x| { x.canonicalize_types(epoch); - Some(x) + x })) } diff --git a/clarity/src/vm/analysis/arithmetic_checker/mod.rs b/clarity/src/vm/analysis/arithmetic_checker/mod.rs index aa69f650f0..429907b4c6 100644 --- a/clarity/src/vm/analysis/arithmetic_checker/mod.rs +++ b/clarity/src/vm/analysis/arithmetic_checker/mod.rs @@ -68,7 +68,7 @@ impl std::fmt::Display for Error { } } -impl<'a> ArithmeticOnlyChecker<'a> { +impl ArithmeticOnlyChecker<'_> { pub fn check_contract_cost_eligible(contract_analysis: &mut ContractAnalysis) { let is_eligible = ArithmeticOnlyChecker::run(contract_analysis).is_ok(); contract_analysis.is_cost_contract_eligible = is_eligible; diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs index 6d91f33b1c..4e0aa9a0cb 100644 --- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs +++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs @@ -276,7 +276,7 @@ impl ContractInterfaceFunction { outputs: ContractInterfaceFunctionOutput { type_f: match function_type { FunctionType::Fixed(FixedFunction { returns, .. }) => { - ContractInterfaceAtomType::from_type_signature(&returns) + ContractInterfaceAtomType::from_type_signature(returns) } _ => return Err(CheckErrors::Expects( "Contract functions should only have fixed function return types!" @@ -287,7 +287,7 @@ impl ContractInterfaceFunction { }, args: match function_type { FunctionType::Fixed(FixedFunction { args, .. }) => { - ContractInterfaceFunctionArg::from_function_args(&args) + ContractInterfaceFunctionArg::from_function_args(args) } _ => { return Err(CheckErrors::Expects( diff --git a/clarity/src/vm/analysis/errors.rs b/clarity/src/vm/analysis/errors.rs index f86308f8d9..5c3f68c7f9 100644 --- a/clarity/src/vm/analysis/errors.rs +++ b/clarity/src/vm/analysis/errors.rs @@ -207,10 +207,10 @@ impl CheckErrors { /// Does this check error indicate that the transaction should be /// rejected? pub fn rejectable(&self) -> bool { - match &self { - CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_) => true, - _ => false, - } + matches!( + self, + CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_) + ) } } @@ -323,7 +323,7 @@ pub fn check_arguments_at_most(expected: usize, args: &[T]) -> Result<(), Che } } -fn formatted_expected_types(expected_types: &Vec) -> String { +fn formatted_expected_types(expected_types: &[TypeSignature]) -> String { let mut expected_types_joined = format!("'{}'", expected_types[0]); if expected_types.len() > 2 { diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs index d563dce6e8..8dde917df9 100644 --- a/clarity/src/vm/analysis/mod.rs +++ b/clarity/src/vm/analysis/mod.rs @@ -17,7 +17,6 @@ pub mod analysis_db; pub mod arithmetic_checker; pub mod contract_interface_builder; -#[allow(clippy::result_large_err)] pub mod errors; pub mod read_only_checker; pub mod trait_checker; @@ -52,7 +51,7 @@ pub fn mem_type_check( epoch: StacksEpochId, ) -> CheckResult<(Option, ContractAnalysis)> { let contract_identifier = QualifiedContractIdentifier::transient(); - let mut contract = build_ast_with_rules( + let contract = build_ast_with_rules( &contract_identifier, snippet, &mut (), @@ -68,7 +67,7 @@ pub fn mem_type_check( let cost_tracker = LimitedCostTracker::new_free(); match run_analysis( &QualifiedContractIdentifier::transient(), - &mut contract, + &contract, &mut analysis_db, false, cost_tracker, @@ -120,6 +119,7 @@ pub fn type_check( .map_err(|(e, _cost_tracker)| e) } +#[allow(clippy::too_many_arguments)] pub fn run_analysis( contract_identifier: &QualifiedContractIdentifier, expressions: &[SymbolicExpression], diff --git a/clarity/src/vm/analysis/read_only_checker/mod.rs b/clarity/src/vm/analysis/read_only_checker/mod.rs index 006b4f0cfe..f60ce11a44 100644 --- a/clarity/src/vm/analysis/read_only_checker/mod.rs +++ b/clarity/src/vm/analysis/read_only_checker/mod.rs @@ -50,7 +50,7 @@ pub struct ReadOnlyChecker<'a, 'b> { clarity_version: ClarityVersion, } -impl<'a, 'b> AnalysisPass for ReadOnlyChecker<'a, 'b> { +impl AnalysisPass for ReadOnlyChecker<'_, '_> { fn run_pass( epoch: &StacksEpochId, contract_analysis: &mut ContractAnalysis, @@ -250,13 +250,12 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { Ok(result) } - /// Checks the native function application of the function named by the - /// string `function` to `args` to determine whether it is read-only - /// compliant. + /// Checks the native function application of the function named by the string `function` + /// to `args` to determine whether it is read-only compliant. /// /// - Returns `None` if there is no native function named `function`. - /// - If there is such a native function, returns `true` iff this function application is - /// read-only. + /// - If there is such a native function, returns `true` iff this function + /// application is read-only. /// /// # Errors /// - Contract parsing errors @@ -414,15 +413,15 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> { } } - /// Checks the native and user-defined function applications implied by `expressions`. The - /// first expression is used as the function name, and the tail expressions are used as the - /// arguments. + /// Checks the native and user-defined function applications implied by `expressions`. + /// + /// The first expression is used as the function name, and the tail expressions are used as the arguments. /// /// Returns `true` iff the function application is read-only. /// /// # Errors /// - `CheckErrors::NonFunctionApplication` if there is no first expression, or if the first - /// expression is not a `ClarityName`. + /// expression is not a `ClarityName`. /// - `CheckErrors::UnknownFunction` if the first expression does not name a known function. fn check_expression_application_is_read_only( &mut self, diff --git a/clarity/src/vm/analysis/type_checker/contexts.rs b/clarity/src/vm/analysis/type_checker/contexts.rs index 936cc47bc4..356ebf5944 100644 --- a/clarity/src/vm/analysis/type_checker/contexts.rs +++ b/clarity/src/vm/analysis/type_checker/contexts.rs @@ -92,7 +92,7 @@ impl TypeMap { } } -impl<'a> TypingContext<'a> { +impl TypingContext<'_> { pub fn new(epoch: StacksEpochId, clarity_version: ClarityVersion) -> TypingContext<'static> { TypingContext { epoch, diff --git a/clarity/src/vm/analysis/type_checker/mod.rs b/clarity/src/vm/analysis/type_checker/mod.rs index b4f6557c2e..36aa2519cc 100644 --- a/clarity/src/vm/analysis/type_checker/mod.rs +++ b/clarity/src/vm/analysis/type_checker/mod.rs @@ -55,7 +55,7 @@ impl FunctionType { | StacksEpochId::Epoch30 | StacksEpochId::Epoch31 => self.check_args_2_1(accounting, args, clarity_version), StacksEpochId::Epoch10 => { - return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into()) + Err(CheckErrors::Expects("Epoch10 is not supported".into()).into()) } } } @@ -81,17 +81,14 @@ impl FunctionType { self.check_args_by_allowing_trait_cast_2_1(db, clarity_version, func_args) } StacksEpochId::Epoch10 => { - return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into()) + Err(CheckErrors::Expects("Epoch10 is not supported".into()).into()) } } } } fn is_reserved_word_v3(word: &str) -> bool { - match word { - "block-height" => true, - _ => false, - } + word == "block-height" } /// Is this a reserved word that should trigger an analysis error for the given diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs index 2b913a3ac9..77083b88cf 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs @@ -239,10 +239,7 @@ impl FunctionType { Ok(TypeSignature::BoolType) } FunctionType::Binary(_, _, _) => { - return Err(CheckErrors::Expects( - "Binary type should not be reached in 2.05".into(), - ) - .into()) + Err(CheckErrors::Expects("Binary type should not be reached in 2.05".into()).into()) } } } @@ -286,8 +283,8 @@ impl FunctionType { )?; } (expected_type, value) => { - if !expected_type.admits(&StacksEpochId::Epoch2_05, &value)? { - let actual_type = TypeSignature::type_of(&value)?; + if !expected_type.admits(&StacksEpochId::Epoch2_05, value)? { + let actual_type = TypeSignature::type_of(value)?; return Err( CheckErrors::TypeError(expected_type.clone(), actual_type).into() ); @@ -438,41 +435,39 @@ impl<'a, 'b> TypeChecker<'a, 'b> { context: &TypingContext, expected_type: &TypeSignature, ) -> TypeResult { - match (&expr.expr, expected_type) { - ( - LiteralValue(Value::Principal(PrincipalData::Contract(ref contract_identifier))), - TypeSignature::TraitReferenceType(trait_identifier), - ) => { - let contract_to_check = self - .db - .load_contract(&contract_identifier, &StacksEpochId::Epoch2_05)? - .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?; - - let contract_defining_trait = self - .db - .load_contract( - &trait_identifier.contract_identifier, - &StacksEpochId::Epoch2_05, - )? - .ok_or(CheckErrors::NoSuchContract( - trait_identifier.contract_identifier.to_string(), - ))?; - - let trait_definition = contract_defining_trait - .get_defined_trait(&trait_identifier.name) - .ok_or(CheckErrors::NoSuchTrait( - trait_identifier.contract_identifier.to_string(), - trait_identifier.name.to_string(), - ))?; - - contract_to_check.check_trait_compliance( + if let ( + LiteralValue(Value::Principal(PrincipalData::Contract(ref contract_identifier))), + TypeSignature::TraitReferenceType(trait_identifier), + ) = (&expr.expr, expected_type) + { + let contract_to_check = self + .db + .load_contract(contract_identifier, &StacksEpochId::Epoch2_05)? + .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?; + + let contract_defining_trait = self + .db + .load_contract( + &trait_identifier.contract_identifier, &StacksEpochId::Epoch2_05, - trait_identifier, - trait_definition, - )?; - return Ok(expected_type.clone()); - } - (_, _) => {} + )? + .ok_or(CheckErrors::NoSuchContract( + trait_identifier.contract_identifier.to_string(), + ))?; + + let trait_definition = contract_defining_trait + .get_defined_trait(&trait_identifier.name) + .ok_or(CheckErrors::NoSuchTrait( + trait_identifier.contract_identifier.to_string(), + trait_identifier.name.to_string(), + ))?; + + contract_to_check.check_trait_compliance( + &StacksEpochId::Epoch2_05, + trait_identifier, + trait_definition, + )?; + return Ok(expected_type.clone()); } let actual_type = self.type_check(expr, context)?; diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs index 201c307986..3c5ab99029 100644 --- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs @@ -776,8 +776,7 @@ impl TypedNativeFunction { | ReplaceAt | GetStacksBlockInfo | GetTenureInfo => { return Err(CheckErrors::Expects( "Clarity 2+ keywords should not show up in 2.05".into(), - ) - .into()) + )) } }; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs index 7caf775c19..7899b3e27d 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs @@ -247,7 +247,7 @@ impl FunctionType { Err(CheckErrors::IncorrectArgumentCount(arg_types.len(), arg_index).into()), ); } - return (None, Ok(None)); + (None, Ok(None)) } // For the following function types, the visitor will just // tell the processor that any results greater than len 1 or 2 @@ -260,7 +260,7 @@ impl FunctionType { Err(CheckErrors::IncorrectArgumentCount(1, arg_index).into()), ); } - return (None, Ok(None)); + (None, Ok(None)) } FunctionType::ArithmeticBinary | FunctionType::ArithmeticComparison @@ -271,7 +271,7 @@ impl FunctionType { Err(CheckErrors::IncorrectArgumentCount(2, arg_index).into()), ); } - return (None, Ok(None)); + (None, Ok(None)) } } } @@ -576,8 +576,8 @@ impl FunctionType { )?; } (expected_type, value) => { - if !expected_type.admits(&StacksEpochId::Epoch21, &value)? { - let actual_type = TypeSignature::type_of(&value)?; + if !expected_type.admits(&StacksEpochId::Epoch21, value)? { + let actual_type = TypeSignature::type_of(value)?; return Err( CheckErrors::TypeError(expected_type.clone(), actual_type).into() ); @@ -854,7 +854,7 @@ fn clarity2_inner_type_check_type( TypeSignature::CallableType(CallableSubtype::Trait(expected_trait_id)), ) => { let contract_to_check = match db - .load_contract(&contract_identifier, &StacksEpochId::Epoch21)? + .load_contract(contract_identifier, &StacksEpochId::Epoch21)? { Some(contract) => { runtime_cost( @@ -1014,7 +1014,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { build_type_map: bool, ) -> TypeChecker<'a, 'b> { Self { - epoch: epoch.clone(), + epoch: *epoch, db, cost_track, contract_context: ContractContext::new(contract_identifier.clone(), *clarity_version), @@ -1240,6 +1240,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> { .cloned() } + #[allow(clippy::unnecessary_lazy_evaluations)] fn type_check_define_function( &mut self, signature: &[SymbolicExpression], @@ -1440,41 +1441,39 @@ impl<'a, 'b> TypeChecker<'a, 'b> { context: &TypingContext, expected_type: &TypeSignature, ) -> TypeResult { - match (&expr.expr, expected_type) { - ( - LiteralValue(Value::Principal(PrincipalData::Contract(ref contract_identifier))), - TypeSignature::CallableType(CallableSubtype::Trait(trait_identifier)), - ) => { - let contract_to_check = self - .db - .load_contract(&contract_identifier, &StacksEpochId::Epoch21)? - .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?; - - let contract_defining_trait = self - .db - .load_contract( - &trait_identifier.contract_identifier, - &StacksEpochId::Epoch21, - )? - .ok_or(CheckErrors::NoSuchContract( - trait_identifier.contract_identifier.to_string(), - ))?; - - let trait_definition = contract_defining_trait - .get_defined_trait(&trait_identifier.name) - .ok_or(CheckErrors::NoSuchTrait( - trait_identifier.contract_identifier.to_string(), - trait_identifier.name.to_string(), - ))?; - - contract_to_check.check_trait_compliance( + if let ( + LiteralValue(Value::Principal(PrincipalData::Contract(ref contract_identifier))), + TypeSignature::CallableType(CallableSubtype::Trait(trait_identifier)), + ) = (&expr.expr, expected_type) + { + let contract_to_check = self + .db + .load_contract(contract_identifier, &StacksEpochId::Epoch21)? + .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?; + + let contract_defining_trait = self + .db + .load_contract( + &trait_identifier.contract_identifier, &StacksEpochId::Epoch21, - trait_identifier, - &trait_definition, - )?; - return Ok(expected_type.clone()); - } - (_, _) => {} + )? + .ok_or(CheckErrors::NoSuchContract( + trait_identifier.contract_identifier.to_string(), + ))?; + + let trait_definition = contract_defining_trait + .get_defined_trait(&trait_identifier.name) + .ok_or(CheckErrors::NoSuchTrait( + trait_identifier.contract_identifier.to_string(), + trait_identifier.name.to_string(), + ))?; + + contract_to_check.check_trait_compliance( + &StacksEpochId::Epoch21, + trait_identifier, + trait_definition, + )?; + return Ok(expected_type.clone()); } let actual_type = self.type_check(expr, context)?; diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs index 9876062241..95fe6f9bf9 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs @@ -7,9 +7,10 @@ use crate::vm::analysis::CheckError; use crate::vm::types::{BufferLength, SequenceSubtype, TypeSignature}; use crate::vm::SymbolicExpression; -/// to-consensus-buff? admits exactly one argument: -/// * the Clarity value to serialize -/// it returns an `(optional (buff x))` where `x` is the maximum possible +/// `to-consensus-buff?` admits exactly one argument: +/// * the Clarity value to serialize +/// +/// It returns an `(optional (buff x))`, where `x` is the maximum possible /// consensus buffer length based on the inferred type of the supplied value. pub fn check_special_to_consensus_buff( checker: &mut TypeChecker, @@ -25,10 +26,11 @@ pub fn check_special_to_consensus_buff( .map_err(CheckError::from) } -/// from-consensus-buff? admits exactly two arguments: -/// * a type signature indicating the expected return type `t1` -/// * a buffer (of up to max length) -/// it returns an `(optional t1)` +/// `from-consensus-buff?` admits exactly two arguments: +/// * a type signature indicating the expected return type `t1` +/// * a buffer (of up to max length) +/// +/// It returns an `(optional t1)` pub fn check_special_from_consensus_buff( checker: &mut TypeChecker, args: &[SymbolicExpression], diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs index b576277a5b..7769652d25 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs @@ -79,7 +79,7 @@ fn check_special_list_cons( }); costs.push(cost); - if let Some(cur_size) = entries_size.clone() { + if let Some(cur_size) = entries_size { entries_size = cur_size.checked_add(checked.size()?); } if let Some(cur_size) = entries_size { @@ -263,6 +263,7 @@ pub fn check_special_tuple_cons( Ok(TypeSignature::TupleType(tuple_signature)) } +#[allow(clippy::unnecessary_lazy_evaluations)] fn check_special_let( checker: &mut TypeChecker, args: &[SymbolicExpression], @@ -1016,7 +1017,7 @@ impl TypedNativeFunction { /// The return type of `principal-destruct` is a Response, in which the success /// and error types are the same. fn parse_principal_basic_type() -> Result { - Ok(TupleTypeSignature::try_from(vec![ + TupleTypeSignature::try_from(vec![ ("version".into(), BUFF_1.clone()), ("hash-bytes".into(), BUFF_20.clone()), ( @@ -1032,7 +1033,7 @@ impl TypedNativeFunction { "FAIL: PrincipalDestruct failed to initialize type signature" .into(), ) - })?) + }) } TypeSignature::ResponseType(Box::new(( parse_principal_basic_type()?.into(), diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs index 6a097a8cd6..772bdd32a4 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs @@ -274,6 +274,7 @@ pub fn check_special_unwrap_err( inner_unwrap_err(input, checker) } +#[allow(clippy::unnecessary_lazy_evaluations)] fn eval_with_new_binding( body: &SymbolicExpression, bind_name: ClarityName, diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs index 12597c88fa..498b52dcb0 100644 --- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs +++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs @@ -3411,7 +3411,7 @@ fn test_trait_args() { }, TraitIdentifier { name: ClarityName::from("trait-bar"), - contract_identifier: contract_identifier, + contract_identifier, }, )]; diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs index a5a551298c..bd611851b6 100644 --- a/clarity/src/vm/ast/definition_sorter/mod.rs +++ b/clarity/src/vm/ast/definition_sorter/mod.rs @@ -420,7 +420,7 @@ impl Graph { let list = self .adjacency_list .get_mut(src_expr_index) - .ok_or_else(|| ParseErrors::InterpreterFailure)?; + .ok_or(ParseErrors::InterpreterFailure)?; list.push(dst_expr_index); Ok(()) } @@ -491,7 +491,7 @@ impl GraphWalker { fn get_cycling_dependencies( &mut self, graph: &Graph, - sorted_indexes: &Vec, + sorted_indexes: &[usize], ) -> Option> { let mut tainted: HashSet = HashSet::new(); diff --git a/clarity/src/vm/ast/errors.rs b/clarity/src/vm/ast/errors.rs index c1a0914b5f..56f8e40f86 100644 --- a/clarity/src/vm/ast/errors.rs +++ b/clarity/src/vm/ast/errors.rs @@ -113,10 +113,7 @@ impl ParseError { } pub fn rejectable(&self) -> bool { - match self.err { - ParseErrors::InterpreterFailure => true, - _ => false, - } + matches!(self.err, ParseErrors::InterpreterFailure) } pub fn has_pre_expression(&self) -> bool { diff --git a/clarity/src/vm/ast/parser/v1.rs b/clarity/src/vm/ast/parser/v1.rs index 5c2715e9f7..4cef2e5411 100644 --- a/clarity/src/vm/ast/parser/v1.rs +++ b/clarity/src/vm/ast/parser/v1.rs @@ -219,9 +219,7 @@ fn inner_lex(input: &str, max_nesting: u64) -> ParseResult { if !args.is_empty() { self.probe_for_generics( - args[1..].to_vec().into_iter(), + args[1..].iter().copied(), &mut referenced_traits, false, )?; diff --git a/clarity/src/vm/ast/types.rs b/clarity/src/vm/ast/types.rs index aedd31eae3..2071130131 100644 --- a/clarity/src/vm/ast/types.rs +++ b/clarity/src/vm/ast/types.rs @@ -96,6 +96,10 @@ impl PreExpressionsDrain { pub fn len(&self) -> usize { self.len } + + pub fn is_empty(&self) -> bool { + self.len == 0 + } } impl Iterator for PreExpressionsDrain { diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs index 9cd991ec97..4691025a8d 100644 --- a/clarity/src/vm/callables.rs +++ b/clarity/src/vm/callables.rs @@ -37,6 +37,7 @@ use crate::vm::types::{ }; use crate::vm::{eval, Environment, LocalContext, Value}; +#[allow(clippy::type_complexity)] pub enum CallableType { UserFunction(DefinedFunction), NativeFunction(&'static str, NativeHandle, ClarityCostFunction), @@ -244,7 +245,11 @@ impl DefinedFunction { ) .into()); } - if let Some(_) = context.variables.insert(name.clone(), value.clone()) { + if context + .variables + .insert(name.clone(), value.clone()) + .is_some() + { return Err(CheckErrors::NameAlreadyUsed(name.to_string()).into()); } } @@ -286,7 +291,7 @@ impl DefinedFunction { } } - if let Some(_) = context.variables.insert(name.clone(), cast_value) { + if context.variables.insert(name.clone(), cast_value).is_some() { return Err(CheckErrors::NameAlreadyUsed(name.to_string()).into()); } } @@ -323,7 +328,7 @@ impl DefinedFunction { self.name.to_string(), ))?; - let args = self.arg_types.iter().map(|a| a.clone()).collect(); + let args = self.arg_types.to_vec(); if !expected_sig.check_args_trait_compliance(epoch, args)? { return Err( CheckErrors::BadTraitImplementation(trait_name, self.name.to_string()).into(), @@ -393,16 +398,12 @@ impl CallableType { impl FunctionIdentifier { fn new_native_function(name: &str) -> FunctionIdentifier { let identifier = format!("_native_:{}", name); - FunctionIdentifier { - identifier: identifier, - } + FunctionIdentifier { identifier } } fn new_user_function(name: &str, context: &str) -> FunctionIdentifier { let identifier = format!("{}:{}", context, name); - FunctionIdentifier { - identifier: identifier, - } + FunctionIdentifier { identifier } } } @@ -636,12 +637,9 @@ mod test { let cast_list = clarity2_implicit_cast(&list_opt_ty, &list_opt_contract).unwrap(); let items = cast_list.expect_list().unwrap(); for item in items { - match item.expect_optional().unwrap() { - Some(cast_opt) => { - let cast_trait = cast_opt.expect_callable().unwrap(); - assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier); - } - None => (), + if let Some(cast_opt) = item.expect_optional().unwrap() { + let cast_trait = cast_opt.expect_callable().unwrap(); + assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier); } } diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs index 11145ab11a..1e503d1425 100644 --- a/clarity/src/vm/clarity.rs +++ b/clarity/src/vm/clarity.rs @@ -113,6 +113,7 @@ pub trait ClarityConnection { self.with_clarity_db_readonly_owned(|mut db| (to_do(&mut db), db)) } + #[allow(clippy::too_many_arguments)] fn with_readonly_clarity_env( &mut self, mainnet: bool, @@ -151,12 +152,15 @@ pub trait ClarityConnection { pub trait TransactionConnection: ClarityConnection { /// Do something with this connection's Clarity environment that can be aborted - /// with `abort_call_back`. + /// with `abort_call_back`. + /// /// This returns the return value of `to_do`: - /// * the generic term `R` - /// * the asset changes during `to_do` in an `AssetMap` - /// * the Stacks events during the transaction - /// and a `bool` value which is `true` if the `abort_call_back` caused the changes to abort + /// * the generic term `R` + /// * the asset changes during `to_do` in an `AssetMap` + /// * the Stacks events during the transaction + /// + /// and a `bool` value which is `true` if the `abort_call_back` caused the changes to abort. + /// /// If `to_do` returns an `Err` variant, then the changes are aborted. fn with_abort_callback( &mut self, @@ -197,14 +201,14 @@ pub trait TransactionConnection: ClarityConnection { ast_rules, ); - let mut contract_ast = match ast_result { + let contract_ast = match ast_result { Ok(x) => x, Err(e) => return (cost_track, Err(e.into())), }; let result = analysis::run_analysis( identifier, - &mut contract_ast.expressions, + &contract_ast.expressions, db, false, cost_track, @@ -272,7 +276,7 @@ pub trait TransactionConnection: ClarityConnection { }, |_, _| false, ) - .and_then(|(value, assets, events, _)| Ok((value, assets, events))) + .map(|(value, assets, events, _)| (value, assets, events)) } /// Execute a contract call in the current block. diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs index eedc2857fa..b3eb8c9fe5 100644 --- a/clarity/src/vm/contexts.rs +++ b/clarity/src/vm/contexts.rs @@ -180,7 +180,7 @@ impl AssetMap { } } -#[derive(Debug, Clone)] +#[derive(Debug, Clone, Default)] pub struct EventBatch { pub events: Vec, } @@ -243,6 +243,12 @@ pub type StackTrace = Vec; pub const TRANSIENT_CONTRACT_NAME: &str = "__transient"; +impl Default for AssetMap { + fn default() -> Self { + Self::new() + } +} + impl AssetMap { pub fn new() -> AssetMap { AssetMap { @@ -276,11 +282,11 @@ impl AssetMap { asset: &AssetIdentifier, amount: u128, ) -> Result { - let current_amount = match self.token_map.get(principal) { - Some(principal_map) => *principal_map.get(asset).unwrap_or(&0), - None => 0, - }; - + let current_amount = self + .token_map + .get(principal) + .and_then(|x| x.get(asset)) + .unwrap_or(&0); current_amount .checked_add(amount) .ok_or(RuntimeErrorType::ArithmeticOverflow.into()) @@ -393,17 +399,14 @@ impl AssetMap { for (principal, stx_amount) in self.stx_map.drain() { let output_map = map.entry(principal.clone()).or_default(); - output_map.insert( - AssetIdentifier::STX(), - AssetMapEntry::STX(stx_amount as u128), - ); + output_map.insert(AssetIdentifier::STX(), AssetMapEntry::STX(stx_amount)); } for (principal, stx_burned_amount) in self.burn_map.drain() { let output_map = map.entry(principal.clone()).or_default(); output_map.insert( AssetIdentifier::STX_burned(), - AssetMapEntry::Burn(stx_burned_amount as u128), + AssetMapEntry::Burn(stx_burned_amount), ); } @@ -414,7 +417,7 @@ impl AssetMap { } } - return map; + map } pub fn get_stx(&self, principal: &PrincipalData) -> Option { @@ -440,13 +443,8 @@ impl AssetMap { principal: &PrincipalData, asset_identifier: &AssetIdentifier, ) -> Option { - match self.token_map.get(principal) { - Some(ref assets) => match assets.get(asset_identifier) { - Some(value) => Some(*value), - None => None, - }, - None => None, - } + let assets = self.token_map.get(principal)?; + assets.get(asset_identifier).copied() } pub fn get_nonfungible_tokens( @@ -454,13 +452,8 @@ impl AssetMap { principal: &PrincipalData, asset_identifier: &AssetIdentifier, ) -> Option<&Vec> { - match self.asset_map.get(principal) { - Some(ref assets) => match assets.get(asset_identifier) { - Some(values) => Some(values), - None => None, - }, - None => None, - } + let assets = self.asset_map.get(principal)?; + assets.get(asset_identifier) } } @@ -469,23 +462,23 @@ impl fmt::Display for AssetMap { write!(f, "[")?; for (principal, principal_map) in self.token_map.iter() { for (asset, amount) in principal_map.iter() { - write!(f, "{} spent {} {}\n", principal, amount, asset)?; + writeln!(f, "{principal} spent {amount} {asset}")?; } } for (principal, principal_map) in self.asset_map.iter() { for (asset, transfer) in principal_map.iter() { - write!(f, "{} transfered [", principal)?; + write!(f, "{principal} transfered [")?; for t in transfer { - write!(f, "{}, ", t)?; + write!(f, "{t}, ")?; } - write!(f, "] {}\n", asset)?; + writeln!(f, "] {asset}")?; } } for (principal, stx_amount) in self.stx_map.iter() { - write!(f, "{} spent {} microSTX\n", principal, stx_amount)?; + writeln!(f, "{principal} spent {stx_amount} microSTX")?; } for (principal, stx_burn_amount) in self.burn_map.iter() { - write!(f, "{} burned {} microSTX\n", principal, stx_burn_amount)?; + writeln!(f, "{principal} burned {stx_burn_amount} microSTX")?; } write!(f, "]") } @@ -493,7 +486,7 @@ impl fmt::Display for AssetMap { impl EventBatch { pub fn new() -> EventBatch { - EventBatch { events: vec![] } + EventBatch::default() } } @@ -614,12 +607,11 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> { self.begin(); let result = { - let mut initial_context = initial_context.unwrap_or(ContractContext::new( + let initial_context = initial_context.unwrap_or(ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity1, )); - let mut exec_env = - self.get_exec_environment(Some(sender), sponsor, &mut initial_context); + let mut exec_env = self.get_exec_environment(Some(sender), sponsor, &initial_context); f(&mut exec_env) }; @@ -737,7 +729,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> { let mut snapshot = env .global_context .database - .get_stx_balance_snapshot(&recipient) + .get_stx_balance_snapshot(recipient) .unwrap(); snapshot.credit(amount).unwrap(); @@ -949,7 +941,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { program: &str, rules: ast::ASTRules, ) -> Result { - let clarity_version = self.contract_context.clarity_version.clone(); + let clarity_version = self.contract_context.clarity_version; let parsed = ast::build_ast_with_rules( contract_identifier, @@ -961,7 +953,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { )? .expressions; - if parsed.len() < 1 { + if parsed.is_empty() { return Err(RuntimeErrorType::ParseError( "Expected a program of at least length 1".to_string(), ) @@ -981,7 +973,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { let result = { let mut nested_env = Environment::new( - &mut self.global_context, + self.global_context, &contract.contract_context, self.call_stack, self.sender.clone(), @@ -1008,7 +1000,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { pub fn eval_raw_with_rules(&mut self, program: &str, rules: ast::ASTRules) -> Result { let contract_id = QualifiedContractIdentifier::transient(); - let clarity_version = self.contract_context.clarity_version.clone(); + let clarity_version = self.contract_context.clarity_version; let parsed = ast::build_ast_with_rules( &contract_id, @@ -1020,15 +1012,14 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { )? .expressions; - if parsed.len() < 1 { + if parsed.is_empty() { return Err(RuntimeErrorType::ParseError( "Expected a program of at least length 1".to_string(), ) .into()); } let local_context = LocalContext::new(); - let result = { eval(&parsed[0], self, &local_context) }; - result + eval(&parsed[0], self, &local_context) } #[cfg(any(test, feature = "testing"))] @@ -1150,7 +1141,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { Ok(value) => { if let Some(handler) = self.global_context.database.get_cc_special_cases_handler() { handler( - &mut self.global_context, + self.global_context, self.sender.as_ref(), self.sponsor.as_ref(), contract_identifier, @@ -1185,7 +1176,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { let result = { let mut nested_env = Environment::new( - &mut self.global_context, + self.global_context, next_contract_context, self.call_stack, self.sender.clone(), @@ -1240,7 +1231,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { contract_content: &str, ast_rules: ASTRules, ) -> Result<()> { - let clarity_version = self.contract_context.clarity_version.clone(); + let clarity_version = self.contract_context.clarity_version; let contract_ast = ast::build_ast_with_rules( &contract_identifier, @@ -1254,7 +1245,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { contract_identifier, clarity_version, &contract_ast, - &contract_content, + contract_content, ) } @@ -1299,7 +1290,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> { contract_identifier.clone(), contract_content, self.sponsor.clone(), - &mut self.global_context, + self.global_context, contract_version, ); self.drop_memory(memory_use)?; @@ -1561,7 +1552,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> { } pub fn is_top_level(&self) -> bool { - self.asset_maps.len() == 0 + self.asset_maps.is_empty() } fn get_asset_map(&mut self) -> Result<&mut AssetMap> { @@ -1841,6 +1832,12 @@ impl ContractContext { } } +impl Default for LocalContext<'_> { + fn default() -> Self { + Self::new() + } +} + impl<'a> LocalContext<'a> { pub fn new() -> LocalContext<'a> { LocalContext { @@ -1898,6 +1895,12 @@ impl<'a> LocalContext<'a> { } } +impl Default for CallStack { + fn default() -> Self { + Self::new() + } +} + impl CallStack { pub fn new() -> CallStack { CallStack { @@ -1946,10 +1949,10 @@ impl CallStack { } Ok(()) } else { - return Err(InterpreterError::InterpreterError( + Err(InterpreterError::InterpreterError( "Tried to remove item from empty call stack.".to_string(), ) - .into()); + .into()) } } @@ -2149,8 +2152,8 @@ mod test { // not simply rollback the tx and squelch the error as includable. let e = env .stx_transfer( - &PrincipalData::from(u1.clone()), - &PrincipalData::from(u2.clone()), + &PrincipalData::from(u1), + &PrincipalData::from(u2), 1000, &BuffData::empty(), ) diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs index 2113ec6479..a3c7fa7140 100644 --- a/clarity/src/vm/costs/mod.rs +++ b/clarity/src/vm/costs/mod.rs @@ -46,9 +46,9 @@ type Result = std::result::Result; pub const CLARITY_MEMORY_LIMIT: u64 = 100 * 1000 * 1000; // TODO: factor out into a boot lib? -pub const COSTS_1_NAME: &'static str = "costs"; -pub const COSTS_2_NAME: &'static str = "costs-2"; -pub const COSTS_3_NAME: &'static str = "costs-3"; +pub const COSTS_1_NAME: &str = "costs"; +pub const COSTS_2_NAME: &str = "costs-2"; +pub const COSTS_3_NAME: &str = "costs-3"; lazy_static! { static ref COST_TUPLE_TYPE_SIGNATURE: TypeSignature = { @@ -254,6 +254,7 @@ pub struct TrackerData { } #[derive(Clone)] +#[allow(clippy::large_enum_variant)] pub enum LimitedCostTracker { Limited(TrackerData), Free, @@ -334,11 +335,7 @@ pub enum CostErrors { impl CostErrors { fn rejectable(&self) -> bool { - match self { - CostErrors::InterpreterFailure => true, - CostErrors::Expect(_) => true, - _ => false, - } + matches!(self, CostErrors::InterpreterFailure | CostErrors::Expect(_)) } } @@ -650,7 +647,7 @@ fn load_cost_functions( continue; } for arg in &cost_func_type.args { - if &arg.signature != &TypeSignature::UIntType { + if arg.signature != TypeSignature::UIntType { warn!("Confirmed cost proposal invalid: contains non uint argument"; "confirmed_proposal_id" => confirmed_proposal, ); @@ -872,7 +869,7 @@ impl TrackerData { .map_err(|e| CostErrors::Expect(e.to_string()))?; } - return Ok(()); + Ok(()) } } @@ -884,7 +881,7 @@ impl LimitedCostTracker { } } #[allow(clippy::panic)] - pub fn set_total(&mut self, total: ExecutionCost) -> () { + pub fn set_total(&mut self, total: ExecutionCost) { // used by the miner to "undo" the cost of a transaction when trying to pack a block. match self { Self::Limited(ref mut data) => data.total = total, @@ -982,8 +979,7 @@ fn compute_cost( .cost_contracts .get_mut(&cost_function_reference.contract_id) .ok_or(CostErrors::CostComputationFailed(format!( - "CostFunction not found: {}", - &cost_function_reference + "CostFunction not found: {cost_function_reference}" )))?; let mut program = vec![SymbolicExpression::atom( @@ -1050,7 +1046,7 @@ impl CostTracker for LimitedCostTracker { match self { Self::Free => { // tracker is free, return zero! - return Ok(ExecutionCost::ZERO); + Ok(ExecutionCost::ZERO) } Self::Limited(ref mut data) => { if cost_function == ClarityCostFunction::Unimplemented { @@ -1062,8 +1058,7 @@ impl CostTracker for LimitedCostTracker { .cost_function_references .get(&cost_function) .ok_or(CostErrors::CostComputationFailed(format!( - "CostFunction not defined: {}", - &cost_function + "CostFunction not defined: {cost_function}" )))? .clone(); @@ -1177,20 +1172,16 @@ pub trait CostOverflowingMath { impl CostOverflowingMath for u64 { fn cost_overflow_mul(self, other: u64) -> Result { - self.checked_mul(other) - .ok_or_else(|| CostErrors::CostOverflow) + self.checked_mul(other).ok_or(CostErrors::CostOverflow) } fn cost_overflow_add(self, other: u64) -> Result { - self.checked_add(other) - .ok_or_else(|| CostErrors::CostOverflow) + self.checked_add(other).ok_or(CostErrors::CostOverflow) } fn cost_overflow_sub(self, other: u64) -> Result { - self.checked_sub(other) - .ok_or_else(|| CostErrors::CostOverflow) + self.checked_sub(other).ok_or(CostErrors::CostOverflow) } fn cost_overflow_div(self, other: u64) -> Result { - self.checked_div(other) - .ok_or_else(|| CostErrors::CostOverflow) + self.checked_div(other).ok_or(CostErrors::CostOverflow) } } @@ -1207,7 +1198,7 @@ impl ExecutionCost { pub fn proportion_largest_dimension(&self, numerator: &ExecutionCost) -> u64 { // max() should always return because there are > 0 elements #[allow(clippy::expect_used)] - [ + *[ numerator.runtime / cmp::max(1, self.runtime / 100), numerator.write_length / cmp::max(1, self.write_length / 100), numerator.write_count / cmp::max(1, self.write_count / 100), @@ -1217,7 +1208,6 @@ impl ExecutionCost { .iter() .max() .expect("BUG: should find maximum") - .clone() } /// Returns the dot product of this execution cost with `resolution`/block_limit diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs index be8a647e9c..862c035f98 100644 --- a/clarity/src/vm/coverage.rs +++ b/clarity/src/vm/coverage.rs @@ -26,6 +26,12 @@ struct CoverageFileInfo { coverage: HashMap>, } +impl Default for CoverageReporter { + fn default() -> Self { + Self::new() + } +} + impl CoverageReporter { pub fn new() -> CoverageReporter { CoverageReporter { diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs index 4f6f3f7781..cbb8bcb4de 100644 --- a/clarity/src/vm/database/clarity_db.rs +++ b/clarity/src/vm/database/clarity_db.rs @@ -82,7 +82,7 @@ impl TryFrom<&str> for StoreType { fn try_from(value: &str) -> core::result::Result { use self::StoreType::*; - let hex_value = u8::from_str_radix(value, 10).map_err(|e| e.to_string())?; + let hex_value = value.parse::().map_err(|e| e.to_string())?; match hex_value { 0x00 => Ok(DataMap), 0x01 => Ok(Variable), @@ -506,7 +506,7 @@ impl<'a> ClarityDatabase<'a> { } pub fn put_data(&mut self, key: &str, value: &T) -> Result<()> { - self.store.put_data(&key, &value.serialize()) + self.store.put_data(key, &value.serialize()) } /// Like `put()`, but returns the serialized byte size of the stored value @@ -516,7 +516,7 @@ impl<'a> ClarityDatabase<'a> { value: &T, ) -> Result { let serialized = value.serialize(); - self.store.put_data(&key, &serialized)?; + self.store.put_data(key, &serialized)?; Ok(byte_len_of_serialization(&serialized)) } @@ -568,7 +568,7 @@ impl<'a> ClarityDatabase<'a> { let size = serialized.len() as u64; let hex_serialized = to_hex(serialized.as_slice()); - self.store.put_data(&key, &hex_serialized)?; + self.store.put_data(key, &hex_serialized)?; Ok(pre_sanitized_size.unwrap_or(size)) } @@ -755,16 +755,14 @@ impl<'a> ClarityDatabase<'a> { &mut self, contract_identifier: &QualifiedContractIdentifier, ) -> Result> { - let x_opt = self - .store + self.store .get_metadata(contract_identifier, AnalysisDatabase::storage_key()) // treat NoSuchContract error thrown by get_metadata as an Option::None -- // the analysis will propagate that as a CheckError anyways. - .ok(); - match x_opt.flatten() { - None => Ok(None), - Some(x) => ContractAnalysis::deserialize(&x).map(|out| Some(out)), - } + .ok() + .flatten() + .map(|x| ContractAnalysis::deserialize(&x)) + .transpose() } pub fn get_contract_size( @@ -978,7 +976,7 @@ impl<'a> ClarityDatabase<'a> { // Get block information -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { /// Returns the ID of a *Stacks* block, by a *Stacks* block height. /// /// Fails if `block_height` >= the "currently" under construction Stacks block height. @@ -1066,7 +1064,7 @@ impl<'a> ClarityDatabase<'a> { let query_tip = self.get_index_block_header_hash(current_height.saturating_sub(1))?; Ok(self .headers_db - .get_stacks_height_for_tenure_height(&query_tip, tenure_height.into())) + .get_stacks_height_for_tenure_height(&query_tip, tenure_height)) } /// Get the last-known burnchain block height. @@ -1158,7 +1156,7 @@ impl<'a> ClarityDatabase<'a> { /// This is the highest Stacks block in this fork whose consensus hash is known. /// 3. Resolve the parent StacksBlockId to its consensus hash /// 4. Resolve the consensus hash to the associated SortitionId - /// In Epoch 3+: + /// In Epoch 3+: /// 1. Get the SortitionId of the current Stacks tip fn get_sortition_id_for_stacks_tip(&mut self) -> Result> { if !self @@ -1276,8 +1274,7 @@ impl<'a> ClarityDatabase<'a> { InterpreterError::Expect( "FATAL: no winning burnchain token spend record for block".into(), ) - })? - .into()) + })?) } pub fn get_miner_spend_total(&mut self, block_height: u32) -> Result { @@ -1294,8 +1291,7 @@ impl<'a> ClarityDatabase<'a> { InterpreterError::Expect( "FATAL: no total burnchain token spend record for block".into(), ) - })? - .into()) + })?) } pub fn get_block_reward(&mut self, block_height: u32) -> Result> { @@ -1316,7 +1312,6 @@ impl<'a> ClarityDatabase<'a> { let reward: u128 = self .headers_db .get_tokens_earned_for_block(&id_bhh, &epoch) - .map(|x| x.into()) .ok_or_else(|| { InterpreterError::Expect("FATAL: matured block has no recorded reward".into()) })?; @@ -1337,7 +1332,7 @@ impl<'a> ClarityDatabase<'a> { // poison-microblock -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { pub fn make_microblock_pubkey_height_key(pubkey_hash: &Hash160) -> String { format!("microblock-pubkey-hash::{}", pubkey_hash) } @@ -1360,6 +1355,7 @@ impl<'a> ClarityDatabase<'a> { self.store.get_cc_special_cases_handler() } + #[allow(clippy::unnecessary_fallible_conversions)] pub fn insert_microblock_poison( &mut self, height: u32, @@ -1451,11 +1447,11 @@ impl<'a> ClarityDatabase<'a> { if let PrincipalData::Standard(principal_data) = reporter_principal { Ok((principal_data, seq)) } else { - return Err(InterpreterError::Expect( + Err(InterpreterError::Expect( "BUG: poison-microblock report principal is not a standard principal" .into(), ) - .into()); + .into()) } }) .transpose() @@ -1472,7 +1468,7 @@ fn map_no_contract_as_none(res: Result>) -> Result> { } // Variable Functions... -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { pub fn create_variable( &mut self, contract_identifier: &QualifiedContractIdentifier, @@ -1605,7 +1601,7 @@ impl<'a> ClarityDatabase<'a> { } // Data Map Functions -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { pub fn create_map( &mut self, contract_identifier: &QualifiedContractIdentifier, @@ -1951,7 +1947,7 @@ impl<'a> ClarityDatabase<'a> { // Asset Functions -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { pub fn create_fungible_token( &mut self, contract_identifier: &QualifiedContractIdentifier, @@ -2294,19 +2290,13 @@ impl<'a> ClarityDatabase<'a> { let key = ClarityDatabase::make_key_for_account_balance(principal); debug!("Fetching account balance"; "principal" => %principal.to_string()); let result = self.get_data(&key)?; - Ok(match result { - None => STXBalance::zero(), - Some(balance) => balance, - }) + Ok(result.unwrap_or_default()) } pub fn get_account_nonce(&mut self, principal: &PrincipalData) -> Result { let key = ClarityDatabase::make_key_for_account_nonce(principal); let result = self.get_data(&key)?; - Ok(match result { - None => 0, - Some(nonce) => nonce, - }) + Ok(result.unwrap_or_default()) } pub fn set_account_nonce(&mut self, principal: &PrincipalData, nonce: u64) -> Result<()> { @@ -2316,7 +2306,7 @@ impl<'a> ClarityDatabase<'a> { } // access burnchain state -impl<'a> ClarityDatabase<'a> { +impl ClarityDatabase<'_> { pub fn get_burn_block_height(&self, sortition_id: &SortitionId) -> Option { self.burn_state_db.get_burn_block_height(sortition_id) } @@ -2328,7 +2318,7 @@ impl<'a> ClarityDatabase<'a> { } pub fn get_stacks_epoch_for_block(&self, id_bhh: &StacksBlockId) -> Result { - let burn_block = self.get_burnchain_block_height(&id_bhh).ok_or_else(|| { + let burn_block = self.get_burnchain_block_height(id_bhh).ok_or_else(|| { InterpreterError::Expect(format!( "FATAL: no burnchain block height found for Stacks block {}", id_bhh diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs index c0b75be83f..eecbe092ea 100644 --- a/clarity/src/vm/database/key_value_wrapper.rs +++ b/clarity/src/vm/database/key_value_wrapper.rs @@ -76,11 +76,11 @@ fn rollback_value_check(value: &String, check: &RollbackValueCheck) { assert_eq!(value, check) } #[cfg(feature = "rollback_value_check")] -fn rollback_edits_push(edits: &mut Vec<(T, RollbackValueCheck)>, key: T, value: &String) +fn rollback_edits_push(edits: &mut Vec<(T, RollbackValueCheck)>, key: T, value: &str) where T: Eq + Hash + Clone, { - edits.push((key, value.clone())); + edits.push((key, value.to_owned())); } // this function is used to check the lookup map when committing at the "bottom" of the // wrapper -- i.e., when committing to the underlying store. @@ -88,7 +88,7 @@ where fn rollback_check_pre_bottom_commit( edits: Vec<(T, RollbackValueCheck)>, lookup_map: &mut HashMap>, -) -> Vec<(T, String)> +) -> Result, InterpreterError> where T: Eq + Hash + Clone, { @@ -96,10 +96,10 @@ where edit_history.reverse(); } for (key, value) in edits.iter() { - rollback_lookup_map(key, &value, lookup_map); + let _ = rollback_lookup_map(key, value, lookup_map); } assert!(lookup_map.is_empty()); - edits + Ok(edits) } /// Result structure for fetched values from the @@ -283,7 +283,7 @@ impl<'a> RollbackWrapper<'a> { // stack is empty, committing to the backing store let all_edits = rollback_check_pre_bottom_commit(last_item.edits, &mut self.lookup_map)?; - if all_edits.len() > 0 { + if !all_edits.is_empty() { self.store.put_all_data(all_edits).map_err(|e| { InterpreterError::Expect(format!( "ERROR: Failed to commit data to sql store: {e:?}" @@ -295,7 +295,7 @@ impl<'a> RollbackWrapper<'a> { last_item.metadata_edits, &mut self.metadata_lookup_map, )?; - if metadata_edits.len() > 0 { + if !metadata_edits.is_empty() { self.store.put_all_metadata(metadata_edits).map_err(|e| { InterpreterError::Expect(format!( "ERROR: Failed to commit data to sql store: {e:?}" @@ -316,12 +316,12 @@ fn inner_put_data( ) where T: Eq + Hash + Clone, { - let key_edit_deque = lookup_map.entry(key.clone()).or_insert_with(|| Vec::new()); + let key_edit_deque = lookup_map.entry(key.clone()).or_default(); rollback_edits_push(edits, key, &value); key_edit_deque.push(value); } -impl<'a> RollbackWrapper<'a> { +impl RollbackWrapper<'_> { pub fn put_data(&mut self, key: &str, value: &str) -> InterpreterResult<()> { let current = self.stack.last_mut().ok_or_else(|| { InterpreterError::Expect( @@ -329,12 +329,13 @@ impl<'a> RollbackWrapper<'a> { ) })?; - Ok(inner_put_data( + inner_put_data( &mut self.lookup_map, &mut current.edits, key.to_string(), value.to_string(), - )) + ); + Ok(()) } /// @@ -347,13 +348,12 @@ impl<'a> RollbackWrapper<'a> { bhh: StacksBlockId, query_pending_data: bool, ) -> InterpreterResult { - self.store.set_block_hash(bhh).map(|x| { + self.store.set_block_hash(bhh).inspect(|_| { // use and_then so that query_pending_data is only set once set_block_hash succeeds // this doesn't matter in practice, because a set_block_hash failure always aborts // the transaction with a runtime error (destroying its environment), but it's much // better practice to do this, especially if the abort behavior changes in the future. self.query_pending_data = query_pending_data; - x }) } @@ -501,12 +501,13 @@ impl<'a> RollbackWrapper<'a> { let metadata_key = (contract.clone(), key.to_string()); - Ok(inner_put_data( + inner_put_data( &mut self.metadata_lookup_map, &mut current.metadata_edits, metadata_key, value.to_string(), - )) + ); + Ok(()) } // Throws a NoSuchContract error if contract doesn't exist, diff --git a/clarity/src/vm/database/mod.rs b/clarity/src/vm/database/mod.rs index d16d944d55..a9c2182806 100644 --- a/clarity/src/vm/database/mod.rs +++ b/clarity/src/vm/database/mod.rs @@ -13,7 +13,6 @@ // // You should have received a copy of the GNU General Public License // along with this program. If not, see . - use hashbrown::HashMap; #[cfg(feature = "canonical")] pub use sqlite::MemoryBackingStore; diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs index e4fab929bd..b88420ff6a 100644 --- a/clarity/src/vm/database/structures.rs +++ b/clarity/src/vm/database/structures.rs @@ -257,7 +257,7 @@ impl ClaritySerializable for STXBalance { impl ClarityDeserializable for STXBalance { fn deserialize(input: &str) -> Result { - let bytes = hex_bytes(&input).map_err(|_| { + let bytes = hex_bytes(input).map_err(|_| { InterpreterError::Expect("STXBalance deserialization: failed decoding bytes.".into()) })?; let result = if bytes.len() == STXBalance::unlocked_and_v1_size { @@ -555,7 +555,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> { ); } - if !(self.balance.amount_locked() <= new_total_locked) { + if self.balance.amount_locked() > new_total_locked { return Err(InterpreterError::Expect( "FATAL: account must lock more after `increase_lock_v2`".into(), ) @@ -623,7 +623,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> { } // caller needs to have checked this - if !(amount_to_lock > 0) { + if amount_to_lock == 0 { return Err(InterpreterError::Expect("BUG: cannot lock 0 tokens".into()).into()); } @@ -980,6 +980,12 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> { } } +impl Default for STXBalance { + fn default() -> Self { + STXBalance::zero() + } +} + // NOTE: do _not_ add mutation methods to this struct. Put them in STXBalanceSnapshot! impl STXBalance { pub const unlocked_and_v1_size: usize = 40; diff --git a/clarity/src/vm/diagnostic.rs b/clarity/src/vm/diagnostic.rs index 81939237d7..164875151f 100644 --- a/clarity/src/vm/diagnostic.rs +++ b/clarity/src/vm/diagnostic.rs @@ -66,24 +66,26 @@ impl Diagnostic { impl fmt::Display for Diagnostic { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self.level)?; - if self.spans.len() == 1 { - write!( + match self.spans.len().cmp(&1) { + std::cmp::Ordering::Equal => write!( f, " (line {}, column {})", self.spans[0].start_line, self.spans[0].start_column - )?; - } else if self.spans.len() > 1 { - let lines: Vec = self - .spans - .iter() - .map(|s| format!("line: {}", s.start_line)) - .collect(); - write!(f, " ({})", lines.join(", "))?; + )?, + std::cmp::Ordering::Greater => { + let lines: Vec = self + .spans + .iter() + .map(|s| format!("line: {}", s.start_line)) + .collect(); + write!(f, " ({})", lines.join(", "))?; + } + _ => {} } write!(f, ": {}.", &self.message)?; if let Some(suggestion) = &self.suggestion { - write!(f, "\n{}", suggestion)?; + write!(f, "\n{suggestion}")?; } - write!(f, "\n") + writeln!(f) } } diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs index b23e356dea..8c9a48f006 100644 --- a/clarity/src/vm/docs/mod.rs +++ b/clarity/src/vm/docs/mod.rs @@ -814,19 +814,19 @@ pub fn get_output_type_string(function_type: &FunctionType) -> String { FunctionType::Binary(left, right, ref out_sig) => match out_sig { FunctionReturnsSignature::Fixed(out_type) => format!("{}", out_type), FunctionReturnsSignature::TypeOfArgAtPosition(pos) => { - let arg_sig: &FunctionArgSignature; - match pos { - 0 => arg_sig = left, - 1 => arg_sig = right, - _ => panic!("Index out of range: TypeOfArgAtPosition for FunctionType::Binary can only handle two arguments, zero-indexed (0 or 1).") - } + let arg_sig = match pos { + 0 => left, + 1 => right, + _ => panic!("Index out of range: TypeOfArgAtPosition for FunctionType::Binary can only handle two arguments, zero-indexed (0 or 1).") + }; + match arg_sig { - FunctionArgSignature::Single(arg_type) => format!("{}", arg_type), - FunctionArgSignature::Union(arg_types) => { - let out_types: Vec = - arg_types.iter().map(|x| format!("{}", x)).collect(); - out_types.join(" | ") - } + FunctionArgSignature::Single(arg_type) => arg_type.to_string(), + FunctionArgSignature::Union(arg_types) => arg_types + .iter() + .map(ToString::to_string) + .collect::>() + .join(" | "), } } }, @@ -835,15 +835,12 @@ pub fn get_output_type_string(function_type: &FunctionType) -> String { pub fn get_signature(function_name: &str, function_type: &FunctionType) -> Option { if let FunctionType::Fixed(FixedFunction { ref args, .. }) = function_type { - let in_names: Vec = args - .iter() - .map(|x| format!("{}", x.name.as_str())) - .collect(); + let in_names: Vec = args.iter().map(|x| x.name.to_string()).collect(); let arg_examples = in_names.join(" "); Some(format!( "({}{}{})", function_name, - if arg_examples.len() == 0 { "" } else { " " }, + if arg_examples.is_empty() { "" } else { " " }, arg_examples )) } else { @@ -860,7 +857,7 @@ fn make_for_simple_native( ) -> FunctionAPI { let (input_type, output_type) = { if let TypedNativeFunction::Simple(SimpleNativeFunction(function_type)) = - TypedNativeFunction::type_native_function(&function) + TypedNativeFunction::type_native_function(function) .expect("Failed to type a native function") { let input_type = get_input_type_string(&function_type); @@ -877,8 +874,8 @@ fn make_for_simple_native( FunctionAPI { name: api.name.map_or(name, |x| x.to_string()), snippet: api.snippet.to_string(), - input_type: input_type, - output_type: output_type, + input_type, + output_type, signature: api.signature.to_string(), description: api.description.to_string(), example: api.example.to_string(), @@ -2526,35 +2523,35 @@ pub fn make_api_reference(function: &NativeFunctions) -> FunctionAPI { use crate::vm::functions::NativeFunctions::*; let name = function.get_name(); match function { - Add => make_for_simple_native(&ADD_API, &function, name), - ToUInt => make_for_simple_native(&TO_UINT_API, &function, name), - ToInt => make_for_simple_native(&TO_INT_API, &function, name), - Subtract => make_for_simple_native(&SUB_API, &function, name), - Multiply => make_for_simple_native(&MUL_API, &function, name), - Divide => make_for_simple_native(&DIV_API, &function, name), - BuffToIntLe => make_for_simple_native(&BUFF_TO_INT_LE_API, &function, name), - BuffToUIntLe => make_for_simple_native(&BUFF_TO_UINT_LE_API, &function, name), - BuffToIntBe => make_for_simple_native(&BUFF_TO_INT_BE_API, &function, name), - BuffToUIntBe => make_for_simple_native(&BUFF_TO_UINT_BE_API, &function, name), - IsStandard => make_for_simple_native(&IS_STANDARD_API, &function, name), - PrincipalDestruct => make_for_simple_native(&PRINCPIPAL_DESTRUCT_API, &function, name), - PrincipalConstruct => make_for_special(&PRINCIPAL_CONSTRUCT_API, &function), - StringToInt => make_for_simple_native(&STRING_TO_INT_API, &function, name), - StringToUInt => make_for_simple_native(&STRING_TO_UINT_API, &function, name), - IntToAscii => make_for_simple_native(&INT_TO_ASCII_API, &function, name), - IntToUtf8 => make_for_simple_native(&INT_TO_UTF8_API, &function, name), - CmpGeq => make_for_simple_native(&GEQ_API, &function, name), - CmpLeq => make_for_simple_native(&LEQ_API, &function, name), - CmpLess => make_for_simple_native(&LESS_API, &function, name), - CmpGreater => make_for_simple_native(&GREATER_API, &function, name), - Modulo => make_for_simple_native(&MOD_API, &function, name), - Power => make_for_simple_native(&POW_API, &function, name), - Sqrti => make_for_simple_native(&SQRTI_API, &function, name), - Log2 => make_for_simple_native(&LOG2_API, &function, name), - BitwiseXor => make_for_simple_native(&XOR_API, &function, name), - And => make_for_simple_native(&AND_API, &function, name), - Or => make_for_simple_native(&OR_API, &function, name), - Not => make_for_simple_native(&NOT_API, &function, name), + Add => make_for_simple_native(&ADD_API, function, name), + ToUInt => make_for_simple_native(&TO_UINT_API, function, name), + ToInt => make_for_simple_native(&TO_INT_API, function, name), + Subtract => make_for_simple_native(&SUB_API, function, name), + Multiply => make_for_simple_native(&MUL_API, function, name), + Divide => make_for_simple_native(&DIV_API, function, name), + BuffToIntLe => make_for_simple_native(&BUFF_TO_INT_LE_API, function, name), + BuffToUIntLe => make_for_simple_native(&BUFF_TO_UINT_LE_API, function, name), + BuffToIntBe => make_for_simple_native(&BUFF_TO_INT_BE_API, function, name), + BuffToUIntBe => make_for_simple_native(&BUFF_TO_UINT_BE_API, function, name), + IsStandard => make_for_simple_native(&IS_STANDARD_API, function, name), + PrincipalDestruct => make_for_simple_native(&PRINCPIPAL_DESTRUCT_API, function, name), + PrincipalConstruct => make_for_special(&PRINCIPAL_CONSTRUCT_API, function), + StringToInt => make_for_simple_native(&STRING_TO_INT_API, function, name), + StringToUInt => make_for_simple_native(&STRING_TO_UINT_API, function, name), + IntToAscii => make_for_simple_native(&INT_TO_ASCII_API, function, name), + IntToUtf8 => make_for_simple_native(&INT_TO_UTF8_API, function, name), + CmpGeq => make_for_simple_native(&GEQ_API, function, name), + CmpLeq => make_for_simple_native(&LEQ_API, function, name), + CmpLess => make_for_simple_native(&LESS_API, function, name), + CmpGreater => make_for_simple_native(&GREATER_API, function, name), + Modulo => make_for_simple_native(&MOD_API, function, name), + Power => make_for_simple_native(&POW_API, function, name), + Sqrti => make_for_simple_native(&SQRTI_API, function, name), + Log2 => make_for_simple_native(&LOG2_API, function, name), + BitwiseXor => make_for_simple_native(&XOR_API, function, name), + And => make_for_simple_native(&AND_API, function, name), + Or => make_for_simple_native(&OR_API, function, name), + Not => make_for_simple_native(&NOT_API, function, name), Equals => make_for_special(&EQUALS_API, function), If => make_for_special(&IF_API, function), Let => make_for_special(&LET_API, function), @@ -2620,20 +2617,20 @@ pub fn make_api_reference(function: &NativeFunctions) -> FunctionAPI { BurnAsset => make_for_special(&BURN_ASSET, function), GetTokenSupply => make_for_special(&GET_TOKEN_SUPPLY, function), AtBlock => make_for_special(&AT_BLOCK, function), - GetStxBalance => make_for_simple_native(&STX_GET_BALANCE, &function, name), - StxGetAccount => make_for_simple_native(&STX_GET_ACCOUNT, &function, name), + GetStxBalance => make_for_simple_native(&STX_GET_BALANCE, function, name), + StxGetAccount => make_for_simple_native(&STX_GET_ACCOUNT, function, name), StxTransfer => make_for_special(&STX_TRANSFER, function), StxTransferMemo => make_for_special(&STX_TRANSFER_MEMO, function), - StxBurn => make_for_simple_native(&STX_BURN, &function, name), + StxBurn => make_for_simple_native(&STX_BURN, function, name), ToConsensusBuff => make_for_special(&TO_CONSENSUS_BUFF, function), FromConsensusBuff => make_for_special(&FROM_CONSENSUS_BUFF, function), ReplaceAt => make_for_special(&REPLACE_AT, function), - BitwiseXor2 => make_for_simple_native(&BITWISE_XOR_API, &function, name), - BitwiseAnd => make_for_simple_native(&BITWISE_AND_API, &function, name), - BitwiseOr => make_for_simple_native(&BITWISE_OR_API, &function, name), - BitwiseNot => make_for_simple_native(&BITWISE_NOT_API, &function, name), - BitwiseLShift => make_for_simple_native(&BITWISE_LEFT_SHIFT_API, &function, name), - BitwiseRShift => make_for_simple_native(&BITWISE_RIGHT_SHIFT_API, &function, name), + BitwiseXor2 => make_for_simple_native(&BITWISE_XOR_API, function, name), + BitwiseAnd => make_for_simple_native(&BITWISE_AND_API, function, name), + BitwiseOr => make_for_simple_native(&BITWISE_OR_API, function, name), + BitwiseNot => make_for_simple_native(&BITWISE_NOT_API, function, name), + BitwiseLShift => make_for_simple_native(&BITWISE_LEFT_SHIFT_API, function, name), + BitwiseRShift => make_for_simple_native(&BITWISE_RIGHT_SHIFT_API, function, name), } } @@ -2726,7 +2723,7 @@ fn make_all_api_reference() -> ReferenceAPIs { .filter_map(make_keyword_reference) .collect(); - keywords.sort_by(|x, y| x.name.cmp(&y.name)); + keywords.sort_by_key(|x| x.name); ReferenceAPIs { functions, @@ -2737,10 +2734,9 @@ fn make_all_api_reference() -> ReferenceAPIs { #[allow(clippy::expect_used)] pub fn make_json_api_reference() -> String { let api_out = make_all_api_reference(); - format!( - "{}", - serde_json::to_string(&api_out).expect("Failed to serialize documentation") - ) + serde_json::to_string(&api_out) + .expect("Failed to serialize documentation") + .to_string() } #[cfg(test)] @@ -2777,7 +2773,7 @@ mod test { const DOC_HEADER_DB: DocHeadersDB = DocHeadersDB {}; impl MemoryBackingStore { - pub fn as_docs_clarity_db<'a>(&'a mut self) -> ClarityDatabase<'a> { + pub fn as_docs_clarity_db(&mut self) -> ClarityDatabase<'_> { ClarityDatabase::new(self, &DOC_HEADER_DB, &DOC_POX_STATE_DB) } } @@ -3001,13 +2997,13 @@ mod test { let mut current_segment: String = "".into(); for line in program.lines() { current_segment.push_str(line); - current_segment.push_str("\n"); + current_segment.push('\n'); if line.contains(";;") && line.contains("Returns ") { segments.push(current_segment); current_segment = "".into(); } } - if current_segment.len() > 0 { + if !current_segment.is_empty() { segments.push(current_segment); } @@ -3067,7 +3063,7 @@ mod test { .type_map .as_ref() .unwrap() - .get_type_expected(&analysis.expressions.last().unwrap()) + .get_type_expected(analysis.expressions.last().unwrap()) .cloned(), ); } @@ -3162,7 +3158,7 @@ mod test { let mut analysis_db = store.as_analysis_db(); let mut parsed = ast::build_ast( &contract_id, - &token_contract_content, + token_contract_content, &mut (), ClarityVersion::latest(), StacksEpochId::latest(), @@ -3232,7 +3228,7 @@ mod test { env.initialize_contract( contract_id, - &token_contract_content, + token_contract_content, None, ASTRules::PrecheckSize, ) diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs index b3b0ca5fea..911465d4ba 100644 --- a/clarity/src/vm/errors.rs +++ b/clarity/src/vm/errors.rs @@ -37,6 +37,7 @@ pub struct IncomparableError { } #[derive(Debug)] +#[allow(clippy::large_enum_variant)] pub enum Error { /// UncheckedErrors are errors that *should* be caught by the /// TypeChecker and other check passes. Test executions may @@ -117,7 +118,7 @@ pub type InterpreterResult = Result; impl PartialEq> for IncomparableError { fn eq(&self, _other: &IncomparableError) -> bool { - return false; + false } } @@ -137,19 +138,16 @@ impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Error::Runtime(ref err, ref stack) => { - match err { - _ => write!(f, "{}", err), - }?; - + write!(f, "{err}")?; if let Some(ref stack_trace) = stack { - write!(f, "\n Stack Trace: \n")?; + writeln!(f, "\n Stack Trace: ")?; for item in stack_trace.iter() { - write!(f, "{}\n", item)?; + writeln!(f, "{item}")?; } } Ok(()) } - _ => write!(f, "{:?}", self), + _ => write!(f, "{self:?}"), } } } @@ -226,9 +224,9 @@ impl From for () { fn from(err: Error) -> Self {} } -impl Into for ShortReturnType { - fn into(self) -> Value { - match self { +impl From for Value { + fn from(val: ShortReturnType) -> Self { + match val { ShortReturnType::ExpectedValue(v) => v, ShortReturnType::AssertionFailed(v) => v, } diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs index 0d004a846a..3dca730928 100644 --- a/clarity/src/vm/functions/assets.rs +++ b/clarity/src/vm/functions/assets.rs @@ -210,6 +210,7 @@ pub fn special_stx_transfer_memo( } } +#[allow(clippy::unnecessary_fallible_conversions)] pub fn special_stx_account( args: &[SymbolicExpression], env: &mut Environment, @@ -286,10 +287,7 @@ pub fn special_stx_burn( env.add_memory(TypeSignature::PrincipalType.size()? as u64)?; env.add_memory(STXBalance::unlocked_and_v1_size as u64)?; - let mut burner_snapshot = env - .global_context - .database - .get_stx_balance_snapshot(&from)?; + let mut burner_snapshot = env.global_context.database.get_stx_balance_snapshot(from)?; if !burner_snapshot.can_transfer(amount)? { return clarity_ecode!(StxErrorCodes::NOT_ENOUGH_BALANCE); } diff --git a/clarity/src/vm/functions/conversions.rs b/clarity/src/vm/functions/conversions.rs index 090f0d2107..142c1308eb 100644 --- a/clarity/src/vm/functions/conversions.rs +++ b/clarity/src/vm/functions/conversions.rs @@ -57,13 +57,13 @@ pub fn buff_to_int_generic( > BufferLength::try_from(16_u32) .map_err(|_| InterpreterError::Expect("Failed to construct".into()))? { - return Err(CheckErrors::TypeValueError( + Err(CheckErrors::TypeValueError( SequenceType(BufferType(BufferLength::try_from(16_u32).map_err( |_| InterpreterError::Expect("Failed to construct".into()), )?)), value, ) - .into()); + .into()) } else { let mut transfer_buffer = [0u8; 16]; let original_slice = sequence_data.as_slice(); @@ -82,15 +82,13 @@ pub fn buff_to_int_generic( Ok(value) } } - _ => { - return Err(CheckErrors::TypeValueError( - SequenceType(BufferType(BufferLength::try_from(16_u32).map_err( - |_| InterpreterError::Expect("Failed to construct".into()), - )?)), - value, - ) - .into()) - } + _ => Err(CheckErrors::TypeValueError( + SequenceType(BufferType(BufferLength::try_from(16_u32).map_err( + |_| InterpreterError::Expect("Failed to construct".into()), + )?)), + value, + ) + .into()), } } diff --git a/clarity/src/vm/functions/crypto.rs b/clarity/src/vm/functions/crypto.rs index dd55f3a56f..86d92283ca 100644 --- a/clarity/src/vm/functions/crypto.rs +++ b/clarity/src/vm/functions/crypto.rs @@ -126,8 +126,8 @@ pub fn special_principal_of( pubkey_to_address_v1(pub_key)? }; let principal = addr.to_account_principal(); - return Ok(Value::okay(Value::Principal(principal)) - .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?); + Ok(Value::okay(Value::Principal(principal)) + .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?) } else { Ok(Value::err_uint(1)) } @@ -169,17 +169,14 @@ pub fn special_secp256k1_recover( _ => return Err(CheckErrors::TypeValueError(BUFF_65.clone(), param1).into()), }; - match secp256k1_recover(&message, &signature).map_err(|_| CheckErrors::InvalidSecp65k1Signature) - { - Ok(pubkey) => { - return Ok(Value::okay( - Value::buff_from(pubkey.to_vec()) - .map_err(|_| InterpreterError::Expect("Failed to construct buff".into()))?, - ) - .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?) - } - _ => return Ok(Value::err_uint(1)), - }; + match secp256k1_recover(message, signature).map_err(|_| CheckErrors::InvalidSecp65k1Signature) { + Ok(pubkey) => Ok(Value::okay( + Value::buff_from(pubkey.to_vec()) + .map_err(|_| InterpreterError::Expect("Failed to construct buff".into()))?, + ) + .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?), + _ => Ok(Value::err_uint(1)), + } } pub fn special_secp256k1_verify( diff --git a/clarity/src/vm/functions/database.rs b/clarity/src/vm/functions/database.rs index ff14507ead..12fb1cd3da 100644 --- a/clarity/src/vm/functions/database.rs +++ b/clarity/src/vm/functions/database.rs @@ -730,14 +730,12 @@ pub fn special_delete_entry_v205( /// - `miner-spend-winner` returns the number of satoshis spent by the winning miner for the block at `block-height` /// - `miner-spend-total` returns the total number of satoshis spent by all miners for the block at `block-height` /// - `block-reward` returns the block reward for the block at `block-height` - /// /// # Errors: /// - CheckErrors::IncorrectArgumentCount if there aren't 2 arguments. /// - CheckErrors::GetStacksBlockInfoExpectPropertyName if `args[0]` isn't a ClarityName. /// - CheckErrors::NoSuchStacksBlockInfoProperty if `args[0]` isn't a StacksBlockInfoProperty. /// - CheckErrors::TypeValueError if `args[1]` isn't a `uint`. - pub fn special_get_block_info( args: &[SymbolicExpression], env: &mut Environment, diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs index 6482493a29..a8971b3fa0 100644 --- a/clarity/src/vm/functions/mod.rs +++ b/clarity/src/vm/functions/mod.rs @@ -79,7 +79,6 @@ mod boolean; mod conversions; mod crypto; mod database; -#[allow(clippy::result_large_err)] pub mod define; mod options; pub mod principals; diff --git a/clarity/src/vm/functions/options.rs b/clarity/src/vm/functions/options.rs index 26829618af..e3305395a5 100644 --- a/clarity/src/vm/functions/options.rs +++ b/clarity/src/vm/functions/options.rs @@ -212,7 +212,7 @@ pub fn special_match( match input { Value::Response(data) => special_match_resp(data, &args[1..], env, context), Value::Optional(data) => special_match_opt(data, &args[1..], env, context), - _ => return Err(CheckErrors::BadMatchInput(TypeSignature::type_of(&input)?).into()), + _ => Err(CheckErrors::BadMatchInput(TypeSignature::type_of(&input)?).into()), } } diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs index ff991f5513..8680c06224 100644 --- a/clarity/src/vm/mod.rs +++ b/clarity/src/vm/mod.rs @@ -13,6 +13,7 @@ // // You should have received a copy of the GNU General Public License // along with this program. If not, see . +#![allow(clippy::result_large_err)] pub mod diagnostic; pub mod errors; @@ -172,33 +173,31 @@ fn lookup_variable(name: &str, context: &LocalContext, env: &mut Environment) -> name )) .into()) + } else if let Some(value) = variables::lookup_reserved_variable(name, context, env)? { + Ok(value) } else { - if let Some(value) = variables::lookup_reserved_variable(name, context, env)? { + runtime_cost( + ClarityCostFunction::LookupVariableDepth, + env, + context.depth(), + )?; + if let Some(value) = context.lookup_variable(name) { + runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?; + Ok(value.clone()) + } else if let Some(value) = env.contract_context.lookup_variable(name).cloned() { + runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?; + let (value, _) = + Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value)?, value) + .ok_or_else(|| CheckErrors::CouldNotDetermineType)?; Ok(value) - } else { - runtime_cost( - ClarityCostFunction::LookupVariableDepth, - env, - context.depth(), - )?; - if let Some(value) = context.lookup_variable(name) { - runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?; - Ok(value.clone()) - } else if let Some(value) = env.contract_context.lookup_variable(name).cloned() { - runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?; - let (value, _) = - Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value)?, value) - .ok_or_else(|| CheckErrors::CouldNotDetermineType)?; - Ok(value) - } else if let Some(callable_data) = context.lookup_callable_contract(name) { - if env.contract_context.get_clarity_version() < &ClarityVersion::Clarity2 { - Ok(callable_data.contract_identifier.clone().into()) - } else { - Ok(Value::CallableContract(callable_data.clone())) - } + } else if let Some(callable_data) = context.lookup_callable_contract(name) { + if env.contract_context.get_clarity_version() < &ClarityVersion::Clarity2 { + Ok(callable_data.contract_identifier.clone().into()) } else { - Err(CheckErrors::UndefinedVariable(name.to_string()).into()) + Ok(Value::CallableContract(callable_data.clone())) } + } else { + Err(CheckErrors::UndefinedVariable(name.to_string()).into()) } } } @@ -238,11 +237,7 @@ pub fn apply( // only enough to do recursion detection. // do recursion check on user functions. - let track_recursion = match function { - CallableType::UserFunction(_) => true, - _ => false, - }; - + let track_recursion = matches!(function, CallableType::UserFunction(_)); if track_recursion && env.call_stack.contains(&identifier) { return Err(CheckErrors::CircularReference(vec![identifier.to_string()]).into()); } @@ -311,9 +306,9 @@ pub fn apply( } } -pub fn eval<'a>( +pub fn eval( exp: &SymbolicExpression, - env: &'a mut Environment, + env: &mut Environment, context: &LocalContext, ) -> Result { use crate::vm::representations::SymbolicExpressionType::{ @@ -329,7 +324,7 @@ pub fn eval<'a>( let res = match exp.expr { AtomValue(ref value) | LiteralValue(ref value) => Ok(value.clone()), - Atom(ref value) => lookup_variable(&value, context, env), + Atom(ref value) => lookup_variable(value, context, env), List(ref children) => { let (function_variable, rest) = children .split_first() @@ -338,8 +333,8 @@ pub fn eval<'a>( let function_name = function_variable .match_atom() .ok_or(CheckErrors::BadFunctionName)?; - let f = lookup_function(&function_name, env)?; - apply(&f, &rest, env, context) + let f = lookup_function(function_name, env)?; + apply(&f, rest, env, context) } TraitReference(_, _) | Field(_) => { return Err(InterpreterError::BadSymbolicRepresentation( @@ -360,13 +355,8 @@ pub fn eval<'a>( } pub fn is_reserved(name: &str, version: &ClarityVersion) -> bool { - if let Some(_result) = functions::lookup_reserved_functions(name, version) { - true - } else if variables::is_reserved_name(name, version) { - true - } else { - false - } + functions::lookup_reserved_functions(name, version).is_some() + || variables::is_reserved_name(name, version) } /// This function evaluates a list of expressions, sharing a global context. @@ -629,7 +619,7 @@ mod test { func_body, DefineType::Private, &"do_work".into(), - &"", + "", ); let context = LocalContext::new(); diff --git a/clarity/src/vm/representations.rs b/clarity/src/vm/representations.rs index c80e3c7467..0f779b479f 100644 --- a/clarity/src/vm/representations.rs +++ b/clarity/src/vm/representations.rs @@ -125,8 +125,8 @@ impl StacksMessageCodec for ClarityName { impl StacksMessageCodec for ContractName { fn consensus_serialize(&self, fd: &mut W) -> Result<(), codec_error> { - if self.as_bytes().len() < CONTRACT_MIN_NAME_LENGTH as usize - || self.as_bytes().len() > CONTRACT_MAX_NAME_LENGTH as usize + if self.as_bytes().len() < CONTRACT_MIN_NAME_LENGTH + || self.as_bytes().len() > CONTRACT_MAX_NAME_LENGTH { return Err(codec_error::SerializeError(format!( "Failed to serialize contract name: too short or too long: {}", diff --git a/clarity/src/vm/test_util/mod.rs b/clarity/src/vm/test_util/mod.rs index 295909859f..861c88ad0a 100644 --- a/clarity/src/vm/test_util/mod.rs +++ b/clarity/src/vm/test_util/mod.rs @@ -70,7 +70,7 @@ pub fn execute_on_network(s: &str, use_mainnet: bool) -> Value { pub fn symbols_from_values(vec: Vec) -> Vec { vec.into_iter() - .map(|value| SymbolicExpression::atom_value(value)) + .map(SymbolicExpression::atom_value) .collect() } diff --git a/clarity/src/vm/tests/assets.rs b/clarity/src/vm/tests/assets.rs index e42f2c59da..e332f72d46 100644 --- a/clarity/src/vm/tests/assets.rs +++ b/clarity/src/vm/tests/assets.rs @@ -1006,7 +1006,7 @@ fn test_simple_naming_system( _ => panic!(), }; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); let tokens_contract_id = @@ -1107,7 +1107,7 @@ fn test_simple_naming_system( assert!(is_committed(&result)); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); assert_eq!( env.eval_read_only(&names_contract_id.clone(), "(nft-get-owner? names 1)") .unwrap(), @@ -1378,7 +1378,7 @@ fn test_simple_naming_system( assert_eq!(asset_map.to_table().len(), 0); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); assert_eq!( env.eval_read_only(&names_contract_id.clone(), "(nft-get-owner? names 5)") .unwrap(), diff --git a/clarity/src/vm/tests/contracts.rs b/clarity/src/vm/tests/contracts.rs index 9cb5aea4b1..94433958c4 100644 --- a/clarity/src/vm/tests/contracts.rs +++ b/clarity/src/vm/tests/contracts.rs @@ -119,7 +119,7 @@ fn test_get_block_info_eval( Ok(Value::none()), ]; - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); @@ -138,7 +138,7 @@ fn test_get_block_info_eval( ) .unwrap(); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); eprintln!("{}", contracts[i]); let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); match expected[i] { @@ -172,13 +172,13 @@ fn test_contract_caller(epoch: StacksEpochId, mut env_factory: MemoryEnvironment (as-contract (contract-call? .contract-a get-caller)))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-a").unwrap(), contract_a, @@ -200,7 +200,7 @@ fn test_contract_caller(epoch: StacksEpochId, mut env_factory: MemoryEnvironment let mut env = owned_env.get_exec_environment( Some(p1.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -312,7 +312,7 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener .expect_principal() .unwrap(); let p2 = execute("'SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); @@ -324,11 +324,8 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener }; { - let mut env = owned_env.get_exec_environment( - Some(p1.clone()), - sponsor.clone(), - &mut placeholder_context, - ); + let mut env = + owned_env.get_exec_environment(Some(p1.clone()), sponsor.clone(), &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-a").unwrap(), contract_a, @@ -345,11 +342,8 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener // Sponsor is equal to some(principal) in this code block. { - let mut env = owned_env.get_exec_environment( - Some(p1.clone()), - sponsor.clone(), - &mut placeholder_context, - ); + let mut env = + owned_env.get_exec_environment(Some(p1.clone()), sponsor.clone(), &placeholder_context); tx_sponsor_contract_asserts(&mut env, sponsor); } @@ -357,7 +351,7 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener { let sponsor = None; let mut env = - owned_env.get_exec_environment(Some(p1), sponsor.clone(), &mut placeholder_context); + owned_env.get_exec_environment(Some(p1), sponsor.clone(), &placeholder_context); tx_sponsor_contract_asserts(&mut env, sponsor); } } @@ -381,13 +375,13 @@ fn test_fully_qualified_contract_call( (as-contract (contract-call? .contract-a get-caller)))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-a").unwrap(), contract_a, @@ -409,7 +403,7 @@ fn test_fully_qualified_contract_call( let mut env = owned_env.get_exec_environment( Some(p1.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -520,13 +514,13 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let name_hash_expensive_0 = execute("(hash160 1)"); let name_hash_expensive_1 = execute("(hash160 2)"); let name_hash_cheap_0 = execute("(hash160 100001)"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); let contract_identifier = QualifiedContractIdentifier::local("tokens").unwrap(); env.initialize_contract(contract_identifier, tokens_contract, ASTRules::PrecheckSize) @@ -541,7 +535,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(p2.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert!(is_err_code( @@ -560,7 +554,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(p1.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert!(is_committed( &env.execute_contract( @@ -588,7 +582,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(p2.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert!(is_err_code( &env.execute_contract( @@ -607,7 +601,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert!(is_committed( &env.execute_contract( @@ -625,7 +619,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(p2.clone().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert!(is_committed( &env.execute_contract( @@ -690,7 +684,7 @@ fn test_simple_contract_call(epoch: StacksEpochId, mut env_factory: MemoryEnviro (contract-call? .factorial-contract compute 8008)) "; - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); @@ -698,7 +692,7 @@ fn test_simple_contract_call(epoch: StacksEpochId, mut env_factory: MemoryEnviro let mut env = owned_env.get_exec_environment( Some(get_principal().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let contract_identifier = QualifiedContractIdentifier::local("factorial-contract").unwrap(); @@ -776,12 +770,12 @@ fn test_aborts(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenerator (contract-call? .contract-1 modify-data 105 105) (err 1))) "; - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); let contract_identifier = QualifiedContractIdentifier::local("contract-1").unwrap(); env.initialize_contract(contract_identifier, contract_1, ASTRules::PrecheckSize) @@ -890,12 +884,12 @@ fn test_aborts(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenerator fn test_factorial_contract(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenerator) { let mut owned_env = env_factory.get_env(epoch); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); let contract_identifier = QualifiedContractIdentifier::local("factorial").unwrap(); env.initialize_contract( @@ -1092,9 +1086,9 @@ fn test_cc_stack_depth( 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1) 1)) (bar) "; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); let contract_identifier = QualifiedContractIdentifier::local("c-foo").unwrap(); env.initialize_contract(contract_identifier, contract_one, ASTRules::PrecheckSize) @@ -1133,9 +1127,9 @@ fn test_cc_trait_stack_depth( (bar .c-foo) "; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); let contract_identifier = QualifiedContractIdentifier::local("c-foo").unwrap(); env.initialize_contract(contract_identifier, contract_one, ASTRules::PrecheckSize) @@ -1156,7 +1150,7 @@ fn test_eval_with_non_existing_contract( ) { let mut owned_env = env_factory.get_env(epoch); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); @@ -1164,7 +1158,7 @@ fn test_eval_with_non_existing_contract( let mut env = owned_env.get_exec_environment( Some(get_principal().expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let result = env.eval_read_only( diff --git a/clarity/src/vm/tests/mod.rs b/clarity/src/vm/tests/mod.rs index 5fa58b507b..cada7e973b 100644 --- a/clarity/src/vm/tests/mod.rs +++ b/clarity/src/vm/tests/mod.rs @@ -36,7 +36,7 @@ mod traits; mod variables; #[cfg(any(test, feature = "testing"))] -impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> { +impl OwnedEnvironment<'_, '_> { pub fn set_tenure_height(&mut self, tenure_height: u32) { self.context.database.begin(); self.context diff --git a/clarity/src/vm/tests/principals.rs b/clarity/src/vm/tests/principals.rs index 44f3447bad..98db149273 100644 --- a/clarity/src/vm/tests/principals.rs +++ b/clarity/src/vm/tests/principals.rs @@ -711,7 +711,7 @@ fn test_principal_construct_good() { data: Box::new(Value::Principal(PrincipalData::Contract( QualifiedContractIdentifier::new( StandardPrincipalData(22, transfer_buffer), - "hello-world".try_into().unwrap() + "hello-world".into() ) ))) }), @@ -735,7 +735,7 @@ fn test_principal_construct_good() { data: Box::new(Value::Principal(PrincipalData::Contract( QualifiedContractIdentifier::new( StandardPrincipalData(20, transfer_buffer), - "hello-world".try_into().unwrap() + "hello-world".into() ) ))) }), @@ -799,7 +799,7 @@ fn test_principal_construct_good() { data: Box::new(Value::Principal(PrincipalData::Contract( QualifiedContractIdentifier::new( StandardPrincipalData(26, transfer_buffer), - "hello-world".try_into().unwrap() + "hello-world".into() ) ))) }), @@ -823,7 +823,7 @@ fn test_principal_construct_good() { data: Box::new(Value::Principal(PrincipalData::Contract( QualifiedContractIdentifier::new( StandardPrincipalData(21, transfer_buffer), - "hello-world".try_into().unwrap() + "hello-world".into() ) ))) }), @@ -854,7 +854,7 @@ fn create_principal_from_strings( // contract principal requested Value::Principal(PrincipalData::Contract(QualifiedContractIdentifier::new( StandardPrincipalData(version_array[0], principal_array), - name.try_into().unwrap(), + name.into(), ))) } else { // standard principal requested diff --git a/clarity/src/vm/tests/simple_apply_eval.rs b/clarity/src/vm/tests/simple_apply_eval.rs index d9e52c0222..f6dbd87090 100644 --- a/clarity/src/vm/tests/simple_apply_eval.rs +++ b/clarity/src/vm/tests/simple_apply_eval.rs @@ -73,7 +73,7 @@ fn test_simple_let(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId (+ z y)) x))"; let contract_id = QualifiedContractIdentifier::transient(); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); if let Ok(parsed_program) = parse(&contract_id, program, version, epoch) { let context = LocalContext::new(); @@ -84,7 +84,7 @@ fn test_simple_let(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId Ok(Value::Int(7)), eval( &parsed_program[0], - &mut env.get_exec_environment(None, None, &mut placeholder_context), + &mut env.get_exec_environment(None, None, &placeholder_context), &context ) ); diff --git a/clarity/src/vm/tests/traits.rs b/clarity/src/vm/tests/traits.rs index 97c4292b0d..d3fcfb7779 100644 --- a/clarity/src/vm/tests/traits.rs +++ b/clarity/src/vm/tests/traits.rs @@ -40,11 +40,11 @@ fn test_dynamic_dispatch_by_defining_trait( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -66,7 +66,7 @@ fn test_dynamic_dispatch_by_defining_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -98,11 +98,11 @@ fn test_dynamic_dispatch_pass_trait_nested_in_let( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -124,7 +124,7 @@ fn test_dynamic_dispatch_pass_trait_nested_in_let( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -155,11 +155,11 @@ fn test_dynamic_dispatch_pass_trait( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -181,7 +181,7 @@ fn test_dynamic_dispatch_pass_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -211,11 +211,11 @@ fn test_dynamic_dispatch_intra_contract_call( (define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-trait").unwrap(), contract_defining_trait, @@ -237,7 +237,7 @@ fn test_dynamic_dispatch_intra_contract_call( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -270,11 +270,11 @@ fn test_dynamic_dispatch_by_implementing_imported_trait( (define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-trait").unwrap(), contract_defining_trait, @@ -302,7 +302,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -335,11 +335,11 @@ fn test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs( (define-public (get-2 (x uint)) (ok u2))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-trait").unwrap(), contract_defining_trait, @@ -367,7 +367,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -397,11 +397,11 @@ fn test_dynamic_dispatch_by_importing_trait( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-trait").unwrap(), contract_defining_trait, @@ -429,7 +429,7 @@ fn test_dynamic_dispatch_by_importing_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -466,11 +466,11 @@ fn test_dynamic_dispatch_including_nested_trait( let target_nested_contract = "(define-public (get-a (x uint)) (ok u99))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-nested-trait").unwrap(), contract_defining_nested_trait, @@ -513,7 +513,7 @@ fn test_dynamic_dispatch_including_nested_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -542,11 +542,11 @@ fn test_dynamic_dispatch_mismatched_args( let target_contract = "(define-public (get-1 (x int)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -568,7 +568,7 @@ fn test_dynamic_dispatch_mismatched_args( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -599,11 +599,11 @@ fn test_dynamic_dispatch_mismatched_returned( let target_contract = "(define-public (get-1 (x uint)) (ok 1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -625,7 +625,7 @@ fn test_dynamic_dispatch_mismatched_returned( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -659,11 +659,11 @@ fn test_reentrant_dynamic_dispatch( "(define-public (get-1 (x uint)) (contract-call? .dispatching-contract wrapped-get-1 .target-contract))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -685,7 +685,7 @@ fn test_reentrant_dynamic_dispatch( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -716,11 +716,11 @@ fn test_readwrite_dynamic_dispatch( let target_contract = "(define-read-only (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -742,7 +742,7 @@ fn test_readwrite_dynamic_dispatch( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -773,11 +773,11 @@ fn test_readwrite_violation_dynamic_dispatch( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -799,7 +799,7 @@ fn test_readwrite_violation_dynamic_dispatch( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); let err_result = env .execute_contract( @@ -837,11 +837,11 @@ fn test_bad_call_with_trait( (contract-call? .dispatch wrapped-get-1 contract))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("defun").unwrap(), contract_defining_trait, @@ -872,7 +872,7 @@ fn test_bad_call_with_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -905,11 +905,11 @@ fn test_good_call_with_trait( (contract-call? .dispatch wrapped-get-1 .implem))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("defun").unwrap(), contract_defining_trait, @@ -940,7 +940,7 @@ fn test_good_call_with_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -974,11 +974,11 @@ fn test_good_call_2_with_trait( (contract-call? .dispatch wrapped-get-1 contract))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("defun").unwrap(), contract_defining_trait, @@ -1012,7 +1012,7 @@ fn test_good_call_2_with_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( @@ -1045,11 +1045,11 @@ fn test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functio (define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("contract-defining-trait").unwrap(), contract_defining_trait, @@ -1077,7 +1077,7 @@ fn test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functio let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1108,11 +1108,11 @@ fn test_contract_of_value( (define-public (get-1 (x uint)) (ok u99))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("defun").unwrap(), contract_defining_trait, @@ -1141,7 +1141,7 @@ fn test_contract_of_value( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( @@ -1175,11 +1175,11 @@ fn test_contract_of_no_impl( (define-public (get-1 (x uint)) (ok u99))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("defun").unwrap(), contract_defining_trait, @@ -1208,7 +1208,7 @@ fn test_contract_of_no_impl( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( @@ -1240,11 +1240,11 @@ fn test_return_trait_with_contract_of_wrapped_in_begin( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1266,7 +1266,7 @@ fn test_return_trait_with_contract_of_wrapped_in_begin( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1297,11 +1297,11 @@ fn test_return_trait_with_contract_of_wrapped_in_let( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1323,7 +1323,7 @@ fn test_return_trait_with_contract_of_wrapped_in_let( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1352,11 +1352,11 @@ fn test_return_trait_with_contract_of( let target_contract = "(define-public (get-1 (x uint)) (ok u1))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1378,7 +1378,7 @@ fn test_return_trait_with_contract_of( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1414,13 +1414,13 @@ fn test_pass_trait_to_subtrait(epoch: StacksEpochId, mut env_factory: MemoryEnvi (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1443,7 +1443,7 @@ fn test_pass_trait_to_subtrait(epoch: StacksEpochId, mut env_factory: MemoryEnvi let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1476,13 +1476,13 @@ fn test_embedded_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentG let target_contract = "(define-public (echo (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1506,7 +1506,7 @@ fn test_embedded_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentG let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1549,13 +1549,13 @@ fn test_pass_embedded_trait_to_subtrait_optional( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1578,7 +1578,7 @@ fn test_pass_embedded_trait_to_subtrait_optional( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1621,13 +1621,13 @@ fn test_pass_embedded_trait_to_subtrait_ok( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1650,7 +1650,7 @@ fn test_pass_embedded_trait_to_subtrait_ok( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1693,13 +1693,13 @@ fn test_pass_embedded_trait_to_subtrait_err( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1722,7 +1722,7 @@ fn test_pass_embedded_trait_to_subtrait_err( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1765,13 +1765,13 @@ fn test_pass_embedded_trait_to_subtrait_list( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1794,7 +1794,7 @@ fn test_pass_embedded_trait_to_subtrait_list( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1840,13 +1840,13 @@ fn test_pass_embedded_trait_to_subtrait_list_option( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1869,7 +1869,7 @@ fn test_pass_embedded_trait_to_subtrait_list_option( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1915,13 +1915,13 @@ fn test_pass_embedded_trait_to_subtrait_option_list( (define-public (get-2 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -1944,7 +1944,7 @@ fn test_pass_embedded_trait_to_subtrait_option_list( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -1976,13 +1976,13 @@ fn test_let_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenera let target_contract = "(define-public (echo (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -2005,7 +2005,7 @@ fn test_let_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenera let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -2041,13 +2041,13 @@ fn test_let3_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener let target_contract = "(define-public (echo (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -2070,7 +2070,7 @@ fn test_let3_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( @@ -2102,13 +2102,13 @@ fn test_pass_principal_literal_to_trait( let target_contract = "(define-public (get-1 (a uint)) (ok a))"; let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR"); - let mut placeholder_context = ContractContext::new( + let placeholder_context = ContractContext::new( QualifiedContractIdentifier::transient(), ClarityVersion::Clarity2, ); { - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); env.initialize_contract( QualifiedContractIdentifier::local("dispatching-contract").unwrap(), dispatching_contract, @@ -2131,7 +2131,7 @@ fn test_pass_principal_literal_to_trait( let mut env = owned_env.get_exec_environment( Some(p1.expect_principal().unwrap()), None, - &mut placeholder_context, + &placeholder_context, ); assert_eq!( env.execute_contract( diff --git a/clarity/src/vm/tests/variables.rs b/clarity/src/vm/tests/variables.rs index 5b392bb678..e862aeb0df 100644 --- a/clarity/src/vm/tests/variables.rs +++ b/clarity/src/vm/tests/variables.rs @@ -36,13 +36,13 @@ fn test_block_height( ) { let contract = "(define-read-only (test-func) block-height)"; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); let mut owned_env = tl_env_factory.get_env(epoch); let contract_identifier = QualifiedContractIdentifier::local("test-contract").unwrap(); - let mut exprs = parse(&contract_identifier, &contract, version, epoch).unwrap(); + let mut exprs = parse(&contract_identifier, contract, version, epoch).unwrap(); let mut marf = MemoryBackingStore::new(); let mut db = marf.as_analysis_db(); let analysis = db.execute(|db| { @@ -70,7 +70,7 @@ fn test_block_height( ASTRules::PrecheckSize, ); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); // Call the function let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); @@ -94,13 +94,13 @@ fn test_stacks_block_height( ) { let contract = "(define-read-only (test-func) stacks-block-height)"; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); let mut owned_env = tl_env_factory.get_env(epoch); let contract_identifier = QualifiedContractIdentifier::local("test-contract").unwrap(); - let mut exprs = parse(&contract_identifier, &contract, version, epoch).unwrap(); + let mut exprs = parse(&contract_identifier, contract, version, epoch).unwrap(); let mut marf = MemoryBackingStore::new(); let mut db = marf.as_analysis_db(); let analysis = db.execute(|db| { @@ -128,7 +128,7 @@ fn test_stacks_block_height( ASTRules::PrecheckSize, ); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); // Call the function let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); @@ -154,13 +154,13 @@ fn test_tenure_height( ) { let contract = "(define-read-only (test-func) tenure-height)"; - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::transient(), version); let mut owned_env = tl_env_factory.get_env(epoch); let contract_identifier = QualifiedContractIdentifier::local("test-contract").unwrap(); - let mut exprs = parse(&contract_identifier, &contract, version, epoch).unwrap(); + let mut exprs = parse(&contract_identifier, contract, version, epoch).unwrap(); let mut marf = MemoryBackingStore::new(); let mut db = marf.as_analysis_db(); let analysis = db.execute(|db| { @@ -188,7 +188,7 @@ fn test_tenure_height( ASTRules::PrecheckSize, ); - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); // Call the function let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); @@ -213,6 +213,7 @@ enum WhenError { } #[cfg(test)] +#[allow(clippy::type_complexity)] fn expect_contract_error( version: ClarityVersion, epoch: StacksEpochId, @@ -226,13 +227,13 @@ fn expect_contract_error( )], expected_success: Value, ) { - let mut placeholder_context = + let placeholder_context = ContractContext::new(QualifiedContractIdentifier::local(name).unwrap(), version); let mut owned_env = tl_env_factory.get_env(epoch); let contract_identifier = QualifiedContractIdentifier::local(name).unwrap(); - let mut exprs = parse(&contract_identifier, &contract, version, epoch).unwrap(); + let mut exprs = parse(&contract_identifier, contract, version, epoch).unwrap(); let mut marf = MemoryBackingStore::new(); let mut db = marf.as_analysis_db(); let analysis = db.execute(|db| { @@ -280,7 +281,7 @@ fn expect_contract_error( } } - let mut env = owned_env.get_exec_environment(None, None, &mut placeholder_context); + let mut env = owned_env.get_exec_environment(None, None, &placeholder_context); // Call the function let eval_result = env.eval_read_only(&contract_identifier, "(test-func)"); diff --git a/clarity/src/vm/tooling/mod.rs b/clarity/src/vm/tooling/mod.rs index f218b2ccab..5b89145588 100644 --- a/clarity/src/vm/tooling/mod.rs +++ b/clarity/src/vm/tooling/mod.rs @@ -21,7 +21,7 @@ pub fn mem_type_check( epoch: StacksEpochId, ) -> CheckResult<(Option, ContractAnalysis)> { let contract_identifier = QualifiedContractIdentifier::transient(); - let mut contract = build_ast_with_rules( + let contract = build_ast_with_rules( &contract_identifier, snippet, &mut (), @@ -37,7 +37,7 @@ pub fn mem_type_check( let cost_tracker = LimitedCostTracker::new_free(); match run_analysis( &QualifiedContractIdentifier::transient(), - &mut contract, + &contract, &mut analysis_db, false, cost_tracker, @@ -51,7 +51,7 @@ pub fn mem_type_check( .type_map .as_ref() .unwrap() - .get_type_expected(&x.expressions.last().unwrap()) + .get_type_expected(x.expressions.last().unwrap()) .cloned(); Ok((first_type, x)) } diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs index e1837ee034..ef4b565834 100644 --- a/clarity/src/vm/types/mod.rs +++ b/clarity/src/vm/types/mod.rs @@ -14,9 +14,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -#[allow(clippy::result_large_err)] pub mod serialization; -#[allow(clippy::result_large_err)] pub mod signatures; use std::collections::btree_map::Entry; @@ -279,6 +277,10 @@ impl SequenceData { } } + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + pub fn element_at(self, index: usize) -> Result> { if self.len() <= index { return Ok(None); @@ -613,7 +615,7 @@ pub trait SequencedValue { fn atom_values(&mut self) -> Result> { self.drained_items() .iter() - .map(|item| Ok(SymbolicExpression::atom_value(Self::to_value(&item)?))) + .map(|item| Ok(SymbolicExpression::atom_value(Self::to_value(item)?))) .collect() } } @@ -751,11 +753,11 @@ define_named_enum!(TenureInfoProperty { impl OptionalData { pub fn type_signature(&self) -> std::result::Result { let type_result = match self.data { - Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(&v)?), + Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(v)?), None => TypeSignature::new_option(TypeSignature::NoType), }; type_result.map_err(|_| { - CheckErrors::Expects("Should not have constructed too large of a type.".into()).into() + CheckErrors::Expects("Should not have constructed too large of a type.".into()) }) } } @@ -773,7 +775,7 @@ impl ResponseData { ), }; type_result.map_err(|_| { - CheckErrors::Expects("Should not have constructed too large of a type.".into()).into() + CheckErrors::Expects("Should not have constructed too large of a type.".into()) }) } } @@ -1265,6 +1267,10 @@ impl ListData { .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into()) } + pub fn is_empty(&self) -> bool { + self.data.is_empty() + } + fn append(&mut self, epoch: &StacksEpochId, other_seq: ListData) -> Result<()> { let entry_type_a = self.type_signature.get_list_item_type(); let entry_type_b = other_seq.type_signature.get_list_item_type(); diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs index 7dcda788a8..48030519c8 100644 --- a/clarity/src/vm/types/serialization.rs +++ b/clarity/src/vm/types/serialization.rs @@ -782,14 +782,12 @@ impl Value { expected_type.unwrap(), )); } - } else { - if len as u64 != tuple_type.len() { - // unwrap is safe because of the match condition - #[allow(clippy::unwrap_used)] - return Err(SerializationError::DeserializeExpected( - expected_type.unwrap(), - )); - } + } else if u64::from(len) != tuple_type.len() { + // unwrap is safe because of the match condition + #[allow(clippy::unwrap_used)] + return Err(SerializationError::DeserializeExpected( + expected_type.unwrap(), + )); } Some(tuple_type) } @@ -1344,7 +1342,7 @@ impl ClaritySerializable for u32 { impl ClarityDeserializable for u32 { fn deserialize(input: &str) -> Result { - let bytes = hex_bytes(&input).map_err(|_| { + let bytes = hex_bytes(input).map_err(|_| { InterpreterError::Expect("u32 deserialization: failed decoding bytes.".into()) })?; assert_eq!(bytes.len(), 4); @@ -1419,13 +1417,10 @@ pub mod tests { } fn test_bad_expectation(v: Value, e: TypeSignature) { - assert!( - match Value::try_deserialize_hex(&v.serialize_to_hex().unwrap(), &e, false).unwrap_err() - { - SerializationError::DeserializeExpected(_) => true, - _ => false, - } - ) + assert!(matches!( + Value::try_deserialize_hex(&v.serialize_to_hex().unwrap(), &e, false).unwrap_err(), + SerializationError::DeserializeExpected(_) + )); } #[test] @@ -1704,40 +1699,37 @@ pub mod tests { ); // field number not equal to expectations - assert!(match Value::try_deserialize_hex( - &t_3.serialize_to_hex().unwrap(), - &TypeSignature::type_of(&t_1).unwrap(), - false - ) - .unwrap_err() - { - SerializationError::DeserializeExpected(_) => true, - _ => false, - }); + assert!(matches!( + Value::try_deserialize_hex( + &t_3.serialize_to_hex().unwrap(), + &TypeSignature::type_of(&t_1).unwrap(), + false + ) + .unwrap_err(), + SerializationError::DeserializeExpected(_) + )); // field type mismatch - assert!(match Value::try_deserialize_hex( - &t_2.serialize_to_hex().unwrap(), - &TypeSignature::type_of(&t_1).unwrap(), - false - ) - .unwrap_err() - { - SerializationError::DeserializeExpected(_) => true, - _ => false, - }); + assert!(matches!( + Value::try_deserialize_hex( + &t_2.serialize_to_hex().unwrap(), + &TypeSignature::type_of(&t_1).unwrap(), + false + ) + .unwrap_err(), + SerializationError::DeserializeExpected(_) + )); // field not-present in expected - assert!(match Value::try_deserialize_hex( - &t_1.serialize_to_hex().unwrap(), - &TypeSignature::type_of(&t_4).unwrap(), - false - ) - .unwrap_err() - { - SerializationError::DeserializeExpected(_) => true, - _ => false, - }); + assert!(matches!( + Value::try_deserialize_hex( + &t_1.serialize_to_hex().unwrap(), + &TypeSignature::type_of(&t_4).unwrap(), + false + ) + .unwrap_err(), + SerializationError::DeserializeExpected(_) + )); } #[apply(test_clarity_versions)] diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs index b3984c5251..a85c56ff3e 100644 --- a/clarity/src/vm/types/signatures.rs +++ b/clarity/src/vm/types/signatures.rs @@ -589,9 +589,7 @@ impl TypeSignature { | StacksEpochId::Epoch25 | StacksEpochId::Epoch30 | StacksEpochId::Epoch31 => self.admits_type_v2_1(other), - StacksEpochId::Epoch10 => { - return Err(CheckErrors::Expects("epoch 1.0 not supported".into())) - } + StacksEpochId::Epoch10 => Err(CheckErrors::Expects("epoch 1.0 not supported".into())), } } @@ -678,16 +676,12 @@ impl TypeSignature { } } NoType => Err(CheckErrors::CouldNotDetermineType), - CallableType(_) => { - return Err(CheckErrors::Expects( - "CallableType should not be used in epoch v2.0".into(), - )) - } - ListUnionType(_) => { - return Err(CheckErrors::Expects( - "ListUnionType should not be used in epoch v2.0".into(), - )) - } + CallableType(_) => Err(CheckErrors::Expects( + "CallableType should not be used in epoch v2.0".into(), + )), + ListUnionType(_) => Err(CheckErrors::Expects( + "ListUnionType should not be used in epoch v2.0".into(), + )), _ => Ok(other == self), } } @@ -1162,9 +1156,7 @@ impl TypeSignature { | StacksEpochId::Epoch25 | StacksEpochId::Epoch30 | StacksEpochId::Epoch31 => Self::least_supertype_v2_1(a, b), - StacksEpochId::Epoch10 => { - return Err(CheckErrors::Expects("epoch 1.0 not supported".into())) - } + StacksEpochId::Epoch10 => Err(CheckErrors::Expects("epoch 1.0 not supported".into())), } } @@ -1455,8 +1447,7 @@ impl TypeSignature { // Checks if resulting type signature is of valid size. pub fn construct_parent_list_type(args: &[Value]) -> Result { - let children_types: Result> = - args.iter().map(|x| TypeSignature::type_of(x)).collect(); + let children_types: Result> = args.iter().map(TypeSignature::type_of).collect(); TypeSignature::parent_list_type(&children_types?) } @@ -1660,7 +1651,7 @@ impl TypeSignature { ) -> Result> { let mut trait_signature: BTreeMap = BTreeMap::new(); let functions_types = type_args - .get(0) + .first() .ok_or_else(|| CheckErrors::InvalidTypeDescription)? .match_list() .ok_or(CheckErrors::DefineTraitBadSignature)?; @@ -1682,11 +1673,10 @@ impl TypeSignature { let fn_args_exprs = args[1] .match_list() .ok_or(CheckErrors::DefineTraitBadSignature)?; - let mut fn_args = Vec::with_capacity(fn_args_exprs.len()); - for arg_type in fn_args_exprs.into_iter() { - let arg_t = TypeSignature::parse_type_repr(epoch, arg_type, accounting)?; - fn_args.push(arg_t); - } + let fn_args = fn_args_exprs + .iter() + .map(|arg_type| TypeSignature::parse_type_repr(epoch, arg_type, accounting)) + .collect::>()?; // Extract function's type return - must be a response let fn_return = match TypeSignature::parse_type_repr(epoch, &args[2], accounting) { @@ -1766,7 +1756,6 @@ impl TypeSignature { "FAIL: .size() overflowed on too large of a type. construction should have failed!" .into(), ) - .into() }) } @@ -1885,9 +1874,8 @@ impl TupleTypeSignature { } pub fn size(&self) -> Result { - self.inner_size()?.ok_or_else(|| { - CheckErrors::Expects("size() overflowed on a constructed type.".into()).into() - }) + self.inner_size()? + .ok_or_else(|| CheckErrors::Expects("size() overflowed on a constructed type.".into())) } fn max_depth(&self) -> u8 { diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs index 0a5ed49a6d..40a097088e 100644 --- a/libsigner/src/runloop.rs +++ b/libsigner/src/runloop.rs @@ -120,9 +120,8 @@ impl, R, T: SignerEventTrait> RunningSigner { pub fn join(self) -> Option { debug!("Try join event loop..."); // wait for event receiver join - let _ = self.event_join.join().map_err(|thread_panic| { + let _ = self.event_join.join().inspect_err(|thread_panic| { error!("Event thread panicked with: '{:?}'", &thread_panic); - thread_panic }); info!("Event receiver thread joined"); @@ -131,9 +130,8 @@ impl, R, T: SignerEventTrait> RunningSigner { let result_opt = self .signer_join .join() - .map_err(|thread_panic| { + .inspect_err(|thread_panic| { error!("Event thread panicked with: '{:?}'", &thread_panic); - thread_panic }) .unwrap_or(None);