CRC: revert eager evaluation of expensive errors and general code cleanup

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

clarity/src/vm/analysis/type_checker/v2_1/mod.rs

@@ -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],
@@ -1270,11 +1271,11 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
             if self.epoch.analysis_memory() {
                 let added_memory = u64::from(arg_name.len())
                     .checked_add(arg_type.type_size()?.into())
-                    .ok_or(CostErrors::CostOverflow)?;
+                    .ok_or_else(|| CostErrors::CostOverflow)?;
                 self.add_memory(added_memory)?;
                 tracked_mem = tracked_mem
                     .checked_add(added_memory)
-                    .ok_or(CostErrors::CostOverflow)?;
+                    .ok_or_else(|| CostErrors::CostOverflow)?;
             }
 
             match arg_type {

clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs

@@ -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],
@@ -297,10 +298,10 @@ fn check_special_let(
         if checker.epoch.analysis_memory() {
             let memory_use = u64::from(var_name.len())
                 .checked_add(u64::from(typed_result.type_size()?))
-                .ok_or(CostErrors::CostOverflow)?;
+                .ok_or_else(|| CostErrors::CostOverflow)?;
             added_memory = added_memory
                 .checked_add(memory_use)
-                .ok_or(CostErrors::CostOverflow)?;
+                .ok_or_else(|| CostErrors::CostOverflow)?;
             checker.add_memory(memory_use)?;
         }
         out_context.add_variable_type(var_name.clone(), typed_result, checker.clarity_version);

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,
@@ -292,7 +293,7 @@ fn eval_with_new_binding(
     if checker.epoch.analysis_memory() {
         memory_use = u64::from(bind_name.len())
             .checked_add(u64::from(bind_type.type_size()?))
-            .ok_or(CostErrors::CostOverflow)?;
+            .ok_or_else(|| CostErrors::CostOverflow)?;
         checker.add_memory(memory_use)?;
     }
     checker.contract_context.check_name_used(&bind_name)?;

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 =
-                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).")
-                    };
+                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<String> =
-                            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::<Vec<_>>()
+                        .join(" | "),
                 }
             }
         },
@@ -2723,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,

clarity/src/vm/mod.rs

@@ -355,11 +355,8 @@ pub fn eval(
 }
 
 pub fn is_reserved(name: &str, version: &ClarityVersion) -> bool {
-    if let Some(_result) = functions::lookup_reserved_functions(name, version) {
-        true
-    } else {
-        variables::is_reserved_name(name, version)
-    }
+    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.

clarity/src/vm/types/signatures.rs

@@ -1673,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.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::<Result<_>>()?;
 
             // Extract function's type return - must be a response
             let fn_return = match TypeSignature::parse_type_repr(epoch, &args[2], accounting) {