perf: improvements in clarity analysis

* cow/arcing tuple types and refactoring some checks in analyzer

Author: kantai

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

@@ -37,6 +37,7 @@ use crate::vm::costs::{
     analysis_typecheck_cost, cost_functions, runtime_cost, ClarityCostFunctionReference,
     CostErrors, CostOverflowingMath, CostTracker, ExecutionCost, LimitedCostTracker,
 };
+use crate::vm::diagnostic::Diagnostic;
 use crate::vm::functions::define::DefineFunctionsParsed;
 use crate::vm::functions::NativeFunctions;
 use crate::vm::representations::SymbolicExpressionType::{
@@ -151,7 +152,130 @@ impl TypeChecker<'_, '_> {
 
 pub type TypeResult = CheckResult<TypeSignature>;
 
+pub fn compute_typecheck_cost<T: CostTracker>(
+    track: &mut T,
+    t1: &TypeSignature,
+    t2: &TypeSignature,
+) -> Result<ExecutionCost, CostErrors> {
+    let t1_size = t1.type_size().map_err(|_| CostErrors::CostOverflow)?;
+    let t2_size = t2.type_size().map_err(|_| CostErrors::CostOverflow)?;
+    track.compute_cost(
+        ClarityCostFunction::AnalysisTypeCheck,
+        &[std::cmp::max(t1_size, t2_size).into()],
+    )
+}
+
+pub fn check_argument_len(expected: usize, args_len: usize) -> Result<(), CheckErrors> {
+    if args_len != expected {
+        Err(CheckErrors::IncorrectArgumentCount(expected, args_len))
+    } else {
+        Ok(())
+    }
+}
+
 impl FunctionType {
+    pub fn check_args_visitor_2_1<T: CostTracker>(
+        &self,
+        accounting: &mut T,
+        arg_type: &TypeSignature,
+        arg_index: usize,
+        accumulated_type: Option<&TypeSignature>,
+    ) -> (
+        Option<Result<ExecutionCost, CostErrors>>,
+        CheckResult<Option<TypeSignature>>,
+    ) {
+        match self {
+            // variadic stops checking cost at the first error...
+            FunctionType::Variadic(expected_type, _) => {
+                let cost = Some(compute_typecheck_cost(accounting, expected_type, arg_type));
+                let admitted = match expected_type.admits_type(&StacksEpochId::Epoch21, arg_type) {
+                    Ok(admitted) => admitted,
+                    Err(e) => return (cost, Err(e.into())),
+                };
+                if !admitted {
+                    return (
+                        cost,
+                        Err(CheckErrors::TypeError(expected_type.clone(), arg_type.clone()).into()),
+                    );
+                }
+                (cost, Ok(None))
+            }
+            FunctionType::ArithmeticVariadic => {
+                let cost = Some(compute_typecheck_cost(
+                    accounting,
+                    &TypeSignature::IntType,
+                    arg_type,
+                ));
+                if arg_index == 0 {
+                    let return_type = match arg_type {
+                        TypeSignature::IntType => Ok(Some(TypeSignature::IntType)),
+                        TypeSignature::UIntType => Ok(Some(TypeSignature::UIntType)),
+                        _ => Err(CheckErrors::UnionTypeError(
+                            vec![TypeSignature::IntType, TypeSignature::UIntType],
+                            arg_type.clone(),
+                        )
+                        .into()),
+                    };
+                    (cost, return_type)
+                } else {
+                    let return_type = accumulated_type
+                        .ok_or_else(|| CheckErrors::Expects("Failed to set accumulated type for arg indices >= 1 in variadic arithmetic".into()).into());
+                    let check_result = return_type.and_then(|return_type| {
+                        if arg_type != return_type {
+                            Err(
+                                CheckErrors::TypeError(return_type.clone(), arg_type.clone())
+                                    .into(),
+                            )
+                        } else {
+                            Ok(None)
+                        }
+                    });
+                    (cost, check_result)
+                }
+            }
+            // For the fixed function types, the visitor will just
+            //  tell the processor that any results greater than the args len
+            //  do not need to be stored, because an error will occur before
+            //  further checking anyways
+            FunctionType::Fixed(FixedFunction {
+                args: arg_types, ..
+            }) => {
+                if arg_index >= arg_types.len() {
+                    // note: argument count will be wrong?
+                    return (
+                        None,
+                        Err(CheckErrors::IncorrectArgumentCount(arg_types.len(), arg_index).into()),
+                    );
+                }
+                return (None, Ok(None));
+            }
+            // For the following function types, the visitor will just
+            //  tell the processor that any results greater than len 1 or 2
+            //  do not need to be stored, because an error will occur before
+            //  further checking anyways
+            FunctionType::ArithmeticUnary | FunctionType::UnionArgs(..) => {
+                if arg_index >= 1 {
+                    return (
+                        None,
+                        Err(CheckErrors::IncorrectArgumentCount(1, arg_index).into()),
+                    );
+                }
+                return (None, Ok(None));
+            }
+            FunctionType::ArithmeticBinary
+            | FunctionType::ArithmeticComparison
+            | FunctionType::Binary(..) => {
+                if arg_index >= 2 {
+                    return (
+                        None,
+                        Err(CheckErrors::IncorrectArgumentCount(2, arg_index).into()),
+                    );
+                }
+                return (None, Ok(None));
+            }
+        }
+    }
+
     pub fn check_args_2_1<T: CostTracker>(
         &self,
         accounting: &mut T,
@@ -1017,17 +1141,23 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         args: &[SymbolicExpression],
         context: &TypingContext,
     ) -> TypeResult {
-        let mut types_returned = self.type_check_all(args, context)?;
-
-        let last_return = types_returned
-            .pop()
-            .ok_or(CheckError::new(CheckErrors::CheckerImplementationFailure))?;
-
-        for type_return in types_returned.iter() {
-            if type_return.is_response_type() {
-                return Err(CheckErrors::UncheckedIntermediaryResponses.into());
+        let mut last_return = None;
+        let mut return_failure = Ok(());
+        for ix in 0..args.len() {
+            let type_return = self.type_check(&args[ix], context)?;
+            if ix + 1 < args.len() {
+                if type_return.is_response_type() {
+                    return_failure = Err(CheckErrors::UncheckedIntermediaryResponses);
+                }
+            } else {
+                last_return = Some(type_return);
             }
         }
+
+        let last_return = last_return
+            .ok_or_else(|| CheckError::new(CheckErrors::CheckerImplementationFailure))?;
+        return_failure?;
+
         Ok(last_return)
     }
 
@@ -1052,8 +1182,56 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         epoch: StacksEpochId,
         clarity_version: ClarityVersion,
     ) -> TypeResult {
-        let typed_args = self.type_check_all(args, context)?;
-        func_type.check_args(self, &typed_args, epoch, clarity_version)
+        if epoch <= StacksEpochId::Epoch2_05 {
+            let typed_args = self.type_check_all(args, context)?;
+            return func_type.check_args(self, &typed_args, epoch, clarity_version);
+        }
+        // use func_type visitor pattern
+        let mut accumulated_type = None;
+        let mut total_costs = vec![];
+        let mut check_result = Ok(());
+        let mut accumulated_types = Vec::new();
+        for (arg_ix, arg_expr) in args.iter().enumerate() {
+            let arg_type = self.type_check(arg_expr, context)?;
+            if check_result.is_ok() {
+                let (costs, result) = func_type.check_args_visitor_2_1(
+                    self,
+                    &arg_type,
+                    arg_ix,
+                    accumulated_type.as_ref(),
+                );
+                // add the accumulated type and total cost *before*
+                //  checking for an error: we want the subsequent error handling
+                //  to account for this cost
+                accumulated_types.push(arg_type);
+                total_costs.extend(costs);
+
+                match result {
+                    Ok(Some(returned_type)) => {
+                        accumulated_type = Some(returned_type);
+                    }
+                    Ok(None) => {}
+                    Err(e) => {
+                        check_result = Err(e);
+                    }
+                };
+            }
+        }
+        if let Err(mut check_error) = check_result {
+            if let CheckErrors::IncorrectArgumentCount(expected, _actual) = check_error.err {
+                check_error.err = CheckErrors::IncorrectArgumentCount(expected, args.len());
+                check_error.diagnostic = Diagnostic::err(&check_error.err)
+            }
+            // accumulate the checking costs
+            // the reason we do this now (instead of within the loop) is for backwards compatibility
+            for cost in total_costs.into_iter() {
+                self.add_cost(cost?)?;
+            }
+
+            return Err(check_error);
+        }
+        // otherwise, just invoke the normal checking routine
+        func_type.check_args(self, &accumulated_types, epoch, clarity_version)
     }
 
     fn get_function_type(&self, function_name: &str) -> Option<FunctionType> {

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

@@ -17,8 +17,8 @@
 use stacks_common::types::StacksEpochId;
 
 use super::{
-    check_argument_count, check_arguments_at_least, check_arguments_at_most, no_type, TypeChecker,
-    TypeResult, TypingContext,
+    check_argument_count, check_arguments_at_least, check_arguments_at_most,
+    compute_typecheck_cost, no_type, TypeChecker, TypeResult, TypingContext,
 };
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
@@ -61,14 +61,43 @@ fn check_special_list_cons(
     args: &[SymbolicExpression],
     context: &TypingContext,
 ) -> TypeResult {
-    let typed_args = checker.type_check_all(args, context)?;
-    for type_arg in typed_args.iter() {
-        runtime_cost(
-            ClarityCostFunction::AnalysisListItemsCheck,
-            checker,
-            type_arg.type_size()?,
-        )?;
+    let mut result = Vec::with_capacity(args.len());
+    let mut entries_size: Option<u32> = Some(0);
+    let mut costs = Vec::with_capacity(args.len());
+
+    for arg in args.iter() {
+        // don't use map here, since type_check has side-effects.
+        let checked = checker.type_check(arg, context)?;
+        let cost = checked.type_size().and_then(|ty_size| {
+            checker
+                .compute_cost(
+                    ClarityCostFunction::AnalysisListItemsCheck,
+                    &[ty_size.into()],
+                )
+                .map_err(CheckErrors::from)
+        });
+        costs.push(cost);
+
+        if let Some(cur_size) = entries_size.clone() {
+            entries_size = cur_size.checked_add(checked.size()?);
+        }
+        if let Some(cur_size) = entries_size {
+            if cur_size > MAX_VALUE_SIZE {
+                entries_size = None;
+            }
+        }
+        if entries_size.is_some() {
+            result.push(checked);
+        }
+    }
+
+    for cost in costs.into_iter() {
+        checker.add_cost(cost?)?;
+    }
+    if entries_size.is_none() {
+        return Err(CheckErrors::ValueTooLarge.into());
     }
+    let typed_args = result;
     TypeSignature::parent_list_type(&typed_args)
         .map_err(|x| x.into())
         .map(TypeSignature::from)
@@ -202,18 +231,31 @@ pub fn check_special_tuple_cons(
         args.len(),
     )?;
 
+    let mut type_size = 0u32;
+    let mut cons_error = Ok(());
+
     handle_binding_list(args, |var_name, var_sexp| {
         checker.type_check(var_sexp, context).and_then(|var_type| {
             runtime_cost(
                 ClarityCostFunction::AnalysisTupleItemsCheck,
                 checker,
                 var_type.type_size()?,
             )?;
-            tuple_type_data.push((var_name.clone(), var_type));
+            if type_size < MAX_VALUE_SIZE {
+                type_size = type_size
+                    .saturating_add(var_name.len() as u32)
+                    .saturating_add(var_name.len() as u32)
+                    .saturating_add(var_type.type_size()?)
+                    .saturating_add(var_type.size()?);
+                tuple_type_data.push((var_name.clone(), var_type));
+            } else {
+                cons_error = Err(CheckErrors::BadTupleConstruction);
+            }
             Ok(())
         })
     })?;
 
+    cons_error?;
     let tuple_signature = TupleTypeSignature::try_from(tuple_type_data)
         .map_err(|_e| CheckErrors::BadTupleConstruction)?;
 
@@ -338,15 +380,33 @@ fn check_special_equals(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let arg_types = checker.type_check_all(args, context)?;
+    let mut arg_type = None;
+    let mut costs = Vec::with_capacity(args.len());
 
-    let mut arg_type = arg_types[0].clone();
-    for x_type in arg_types.into_iter() {
-        analysis_typecheck_cost(checker, &x_type, &arg_type)?;
-        arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch21, &x_type, &arg_type)
-            .map_err(|_| CheckErrors::TypeError(x_type, arg_type))?;
+    for arg in args.iter() {
+        let x_type = checker.type_check(arg, context)?;
+        if arg_type.is_none() {
+            arg_type = Some(Ok(x_type.clone()));
+        }
+        if let Some(Ok(cur_type)) = arg_type {
+            let cost = compute_typecheck_cost(checker, &x_type, &cur_type);
+            costs.push(cost);
+            arg_type = Some(
+                TypeSignature::least_supertype(&StacksEpochId::Epoch21, &x_type, &cur_type)
+                    .map_err(|_| CheckErrors::TypeError(x_type, cur_type)),
+            );
+        }
     }
 
+    for cost in costs.into_iter() {
+        checker.add_cost(cost?)?;
+    }
+
+    // check if there was a least supertype failure.
+    arg_type.ok_or_else(|| {
+        CheckErrors::Expects("Arg type should be set because arguments checked for >= 1".into())
+    })??;
+
     Ok(TypeSignature::BoolType)
 }