feat: short-cut traverse function

short-cut the traverse functions that do not have the right argument count.
stacks-network · Oct 23, 2024 · b415867 · b415867
1 parent 90bfb36
commit b415867
Showing 26 changed files with 179 additions and 112 deletions.
diff --git a/clar2wasm/src/wasm_generator.rs b/clar2wasm/src/wasm_generator.rs
@@ -115,6 +115,7 @@ pub enum GeneratorError {
     NotImplemented,
     InternalError(String),
     TypeError(String),
+    ArgumentCountMismatch,
 }
 
 pub enum FunctionKind {
@@ -129,6 +130,7 @@ impl DiagnosableError for GeneratorError {
             GeneratorError::NotImplemented => "Not implemented".to_string(),
             GeneratorError::InternalError(msg) => format!("Internal error: {}", msg),
             GeneratorError::TypeError(msg) => format!("Type error: {}", msg),
+            GeneratorError::ArgumentCountMismatch => "Argument count mismatch".to_string(),
         }
     }
 

diff --git a/clar2wasm/src/wasm_utils.rs b/clar2wasm/src/wasm_utils.rs
@@ -1693,18 +1693,51 @@ pub fn check_argument_count(
         ArgumentCountCheck::Exact => {
             if expected != actual {
                 handle_mismatch(ErrorMap::ArgumentCountMismatch)?;
+                return Err(GeneratorError::ArgumentCountMismatch);
             }
         }
         ArgumentCountCheck::AtLeast => {
             if expected > actual {
                 handle_mismatch(ErrorMap::ArgumentCountAtLeast)?;
+                return Err(GeneratorError::ArgumentCountMismatch);
             }
         }
         ArgumentCountCheck::AtMost => {
             if expected < actual {
                 handle_mismatch(ErrorMap::ArgumentCountAtMost)?;
+                return Err(GeneratorError::ArgumentCountMismatch);
             }
         }
     }
     Ok(())
 }
+
+#[macro_export]
+macro_rules! check_args {
+    ($generator:expr, $builder:expr, $expected:expr, $actual:expr, $check:expr,  $self:expr) => {
+        if check_argument_count($generator, $builder, $expected, $actual, $check).is_err() {
+            if let Some(self_ref) = $self {
+                // short cutting get-block-info? traverse function, it's expecting 3 i32 on stack
+                if self_ref.name() == clarity::vm::ClarityName::from("get-block-info?") {
+                    $builder.i32_const(-1);
+                    $builder.i32_const(-1);
+                    $builder.i32_const(-1);
+                    return Ok(());
+                }
+            }
+            // short cutting traverse functions
+            $builder.i32_const(-1);
+            return Ok(());
+        }
+    };
+    ($generator:expr, $builder:expr, $expected:expr, $actual:expr, $check:expr) => {
+        check_args!(
+            $generator,
+            $builder,
+            $expected,
+            $actual,
+            $check,
+            None::<&Self>
+        );
+    };
+}
diff --git a/clar2wasm/src/words/bindings.rs b/clar2wasm/src/words/bindings.rs
@@ -1,5 +1,6 @@
 use clarity::vm::{ClarityName, SymbolicExpression};
 
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 use crate::words::ComplexWord;
@@ -19,13 +20,13 @@ impl ComplexWord for Let {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             2,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         let bindings = args.get_list(0)?;
 

diff --git a/clar2wasm/src/words/blockinfo.rs b/clar2wasm/src/words/blockinfo.rs
@@ -1,6 +1,7 @@
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -19,7 +20,14 @@ impl ComplexWord for GetBlockInfo {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(
+            generator,
+            builder,
+            2,
+            args.len(),
+            ArgumentCountCheck::Exact,
+            Some(self)
+        );
 
         let prop_name = args.get_name(0)?;
         let block = args.get_expr(1)?;
@@ -73,7 +81,7 @@ impl ComplexWord for GetBurnBlockInfo {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let prop_name = args.get_name(0)?;
         let block = args.get_expr(1)?;
@@ -129,7 +137,7 @@ impl ComplexWord for AtBlock {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let block_hash = args.get_expr(0)?;
         let e = args.get_expr(1)?;
@@ -210,6 +218,18 @@ mod tests {
             )
         }
 
+        #[test]
+        fn get_block_info_less_than_two_args() {
+            let mut env = TestEnvironment::default();
+            env.advance_chain_tip(1);
+            let result = env.evaluate("(get-block-info? id-header-hash)");
+            assert!(result.is_err());
+            assert!(result
+                .unwrap_err()
+                .to_string()
+                .contains("expecting >= 2 arguments, got 1"));
+        }
+
         #[test]
         fn get_block_info_more_than_two_args() {
             // TODO: see issue #488
@@ -218,7 +238,7 @@ mod tests {
             // where certain errors are not properly handled.
             // This test should be re-worked once the typechecker is fixed
             // and can correctly detect all argument inconsistencies.
-            let snippet = "(get-block-info? burnchain-header-hash u0 u0)";
+            let snippet = "(get-block-info? burnchain-header-hash u0 miner-address)";
             let expected = Err(Error::Unchecked(CheckErrors::IncorrectArgumentCount(2, 3)));
             crosscheck_with_epoch(snippet, expected, StacksEpochId::Epoch24);
         }
@@ -267,18 +287,6 @@ mod tests {
 
     //- Block Info
 
-    #[test]
-    fn get_block_info_less_than_two_args() {
-        let mut env = TestEnvironment::default();
-        env.advance_chain_tip(1);
-        let result = env.evaluate("(get-block-info? id-header-hash)");
-        assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("expecting >= 2 arguments, got 1"));
-    }
-
     #[test]
     fn get_block_info_burnchain_header_hash() {
         let mut env = TestEnvironment::default();

diff --git a/clar2wasm/src/words/conditionals.rs b/clar2wasm/src/words/conditionals.rs
@@ -10,7 +10,7 @@ use crate::wasm_generator::{
     SequenceElementType, WasmGenerator,
 };
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
-use crate::words;
+use crate::{check_args, words};
 
 #[derive(Debug)]
 pub struct If;
@@ -27,7 +27,7 @@ impl ComplexWord for If {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let conditional = args.get_expr(0)?;
         let true_branch = args.get_expr(1)?;
@@ -100,7 +100,7 @@ impl ComplexWord for Match {
 
         match generator.get_expr_type(match_on).cloned() {
             Some(TypeSignature::OptionalType(inner_type)) => {
-                check_argument_count(generator, builder, 4, args.len(), ArgumentCountCheck::Exact)?;
+                check_args!(generator, builder, 4, args.len(), ArgumentCountCheck::Exact);
 
                 let none_body = args.get_expr(3)?;
 
@@ -128,7 +128,7 @@ impl ComplexWord for Match {
                 Ok(())
             }
             Some(TypeSignature::ResponseType(inner_types)) => {
-                check_argument_count(generator, builder, 5, args.len(), ArgumentCountCheck::Exact)?;
+                check_args!(generator, builder, 5, args.len(), ArgumentCountCheck::Exact);
 
                 let (ok_ty, err_ty) = &*inner_types;
 
@@ -193,7 +193,8 @@ impl ComplexWord for Filter {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
+
         let discriminator = args.get_name(0)?;
         let sequence = args.get_expr(1)?;
 
@@ -417,13 +418,13 @@ impl ComplexWord for And {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             1,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         traverse_short_circuiting_list(generator, builder, args, false)
     }
@@ -466,13 +467,13 @@ impl ComplexWord for Or {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             1,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         traverse_short_circuiting_list(generator, builder, args, true)
     }
@@ -515,7 +516,7 @@ impl ComplexWord for Unwrap {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         let throw = args.get_expr(1)?;
@@ -598,7 +599,7 @@ impl ComplexWord for UnwrapErr {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         let throw = args.get_expr(1)?;
@@ -689,7 +690,7 @@ impl ComplexWord for Asserts {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         let throw = args.get_expr(1)?;
@@ -766,7 +767,7 @@ impl ComplexWord for Try {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         generator.traverse_expr(builder, input)?;

diff --git a/clar2wasm/src/words/consensus_buff.rs b/clar2wasm/src/words/consensus_buff.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::{TypeSignature, MAX_VALUE_SIZE};
 use walrus::ir::{BinaryOp, InstrSeqType};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{
     add_placeholder_for_clarity_type, clar2wasm_ty, drop_value, ArgumentsExt, GeneratorError,
     WasmGenerator,
@@ -23,7 +24,7 @@ impl ComplexWord for ToConsensusBuff {
         _expr: &clarity::vm::SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), crate::wasm_generator::GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         generator.traverse_args(builder, args)?;
 
@@ -96,7 +97,8 @@ impl ComplexWord for FromConsensusBuff {
         _expr: &clarity::vm::SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
+
         // Rather than parsing the type from args[0], we can just use the type
         // of this expression.
         let ty = generator

diff --git a/clar2wasm/src/words/constants.rs b/clar2wasm/src/words/constants.rs
@@ -2,6 +2,7 @@ use clarity::vm::{ClarityName, SymbolicExpression, SymbolicExpressionType};
 use walrus::{ActiveData, DataKind, ValType};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{
     check_argument_count, get_type_size, is_in_memory_type, ArgumentCountCheck,
@@ -22,7 +23,7 @@ impl ComplexWord for DefineConstant {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         // Constant name
         let name = args.get_name(0)?;

diff --git a/clar2wasm/src/words/contract.rs b/clar2wasm/src/words/contract.rs
@@ -6,6 +6,7 @@ use walrus::ir::BinaryOp;
 use walrus::ValType;
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -24,7 +25,7 @@ impl ComplexWord for AsContract {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let inner = args.get_expr(0)?;
 
@@ -56,13 +57,13 @@ impl ComplexWord for ContractCall {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             2,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         let function_name = args.get_name(1)?;
         let contract_expr = args.get_expr(0)?;

diff --git a/clar2wasm/src/words/control_flow.rs b/clar2wasm/src/words/control_flow.rs
@@ -3,6 +3,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ir::{IfElse, UnaryOp};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::error_mapping::ErrorMap;
 use crate::wasm_generator::{drop_value, ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
@@ -22,13 +23,13 @@ impl ComplexWord for Begin {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             1,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         generator.set_expr_type(
             args.last().ok_or_else(|| {
@@ -58,7 +59,7 @@ impl ComplexWord for UnwrapPanic {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         generator.traverse_expr(builder, input)?;
@@ -196,7 +197,7 @@ impl ComplexWord for UnwrapErrPanic {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let input = args.get_expr(0)?;
         generator.traverse_expr(builder, input)?;

diff --git a/clar2wasm/src/words/data_vars.rs b/clar2wasm/src/words/data_vars.rs
@@ -3,6 +3,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ValType;
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, LiteralMemoryEntry, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -21,7 +22,7 @@ impl ComplexWord for DefineDataVar {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         // Making sure if name is not reserved
@@ -111,7 +112,7 @@ impl ComplexWord for SetDataVar {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         let value = args.get_expr(1)?;
@@ -184,7 +185,7 @@ impl ComplexWord for GetDataVar {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
 

diff --git a/clar2wasm/src/words/default_to.rs b/clar2wasm/src/words/default_to.rs
@@ -3,6 +3,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ir::InstrSeqType;
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{
     clar2wasm_ty, drop_value, ArgumentsExt, GeneratorError, WasmGenerator,
 };
@@ -23,7 +24,7 @@ impl ComplexWord for DefaultTo {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         // There are a `default` value and an `optional` arguments.
         // (default-to 767 (some 1))

diff --git a/clar2wasm/src/words/enums.rs b/clar2wasm/src/words/enums.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{
     add_placeholder_for_type, clar2wasm_ty, ArgumentsExt, GeneratorError, WasmGenerator,
 };
@@ -22,7 +23,7 @@ impl ComplexWord for ClaritySome {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let value = args.get_expr(0)?;
         // (some <val>) is represented by an i32 1, followed by the value
@@ -59,7 +60,7 @@ impl ComplexWord for ClarityOk {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let value = args.get_expr(0)?;
 
@@ -106,7 +107,7 @@ impl ComplexWord for ClarityErr {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let value = args.get_expr(0)?;
         // (err <val>) is represented by an i32 0, followed by a placeholder

diff --git a/clar2wasm/src/words/equal.rs b/clar2wasm/src/words/equal.rs
@@ -5,6 +5,7 @@ use walrus::ir::{BinaryOp, IfElse, InstrSeqType, Loop, UnaryOp};
 use walrus::{InstrSeqBuilder, LocalId, ValType};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{
     clar2wasm_ty, drop_value, ArgumentsExt, GeneratorError, SequenceElementType, WasmGenerator,
 };
@@ -25,13 +26,13 @@ impl ComplexWord for IsEq {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             1,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         // Traverse the first operand pushing it onto the stack
         let first_op = args.get_expr(0)?;
@@ -122,7 +123,7 @@ impl ComplexWord for IndexOf {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         // Traverse the sequence, leaving its offset and size on the stack.
         let seq = args.get_expr(0)?;

diff --git a/clar2wasm/src/words/functions.rs b/clar2wasm/src/words/functions.rs
@@ -1,6 +1,7 @@
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, FunctionKind, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -19,7 +20,7 @@ impl ComplexWord for DefinePrivateFunction {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let Some(signature) = args.get_expr(0)?.match_list() else {
             return Err(GeneratorError::NotImplemented);
@@ -55,7 +56,7 @@ impl ComplexWord for DefineReadonlyFunction {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let Some(signature) = args.get_expr(0)?.match_list() else {
             return Err(GeneratorError::NotImplemented);
@@ -93,7 +94,7 @@ impl ComplexWord for DefinePublicFunction {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let Some(signature) = args.get_expr(0)?.match_list() else {
             return Err(GeneratorError::NotImplemented);

diff --git a/clar2wasm/src/words/maps.rs b/clar2wasm/src/words/maps.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, LiteralMemoryEntry, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -20,7 +21,7 @@ impl ComplexWord for MapDefinition {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         // Making sure if name is not reserved
@@ -82,7 +83,7 @@ impl ComplexWord for MapGet {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         let key = args.get_expr(1)?;
@@ -161,7 +162,7 @@ impl ComplexWord for MapSet {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         let key = args.get_expr(1)?;
@@ -243,7 +244,7 @@ impl ComplexWord for MapInsert {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         let key = args.get_expr(1)?;
@@ -325,7 +326,7 @@ impl ComplexWord for MapDelete {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         let key = args.get_expr(1)?;

diff --git a/clar2wasm/src/words/noop.rs b/clar2wasm/src/words/noop.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::{ComplexWord, SimpleWord};
+use crate::check_args;
 use crate::wasm_generator::{GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -68,7 +69,7 @@ impl ComplexWord for ContractOf {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         generator.traverse_args(builder, args)?;
 

diff --git a/clar2wasm/src/words/options.rs b/clar2wasm/src/words/options.rs
@@ -3,6 +3,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ir::BinaryOp;
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{drop_value, ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -51,7 +52,7 @@ impl ComplexWord for IsSome {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         traverse_optional(generator, builder, args)
     }
@@ -72,7 +73,7 @@ impl ComplexWord for IsNone {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         traverse_optional(generator, builder, args)?;
 

diff --git a/clar2wasm/src/words/principal.rs b/clar2wasm/src/words/principal.rs
@@ -10,6 +10,7 @@ use walrus::ir::{BinaryOp, ExtendedLoad, InstrSeqType, LoadKind, MemArg};
 use walrus::{LocalId, ValType};
 
 use super::{ComplexWord, SimpleWord};
+use crate::check_args;
 use crate::wasm_generator::{
     add_placeholder_for_clarity_type, clar2wasm_ty, ArgumentsExt, GeneratorError, WasmGenerator,
 };
@@ -99,20 +100,20 @@ impl ComplexWord for Construct {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             2,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
-        check_argument_count(
+            ArgumentCountCheck::AtLeast
+        );
+        check_args!(
             generator,
             builder,
             3,
             args.len(),
-            ArgumentCountCheck::AtMost,
-        )?;
+            ArgumentCountCheck::AtMost
+        );
 
         // Traverse the version byte
         generator.traverse_expr(builder, args.get_expr(0)?)?;
@@ -288,7 +289,7 @@ impl ComplexWord for PrincipalOf {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         // Traverse the public key
         generator.traverse_expr(builder, args.get_expr(0)?)?;

diff --git a/clar2wasm/src/words/print.rs b/clar2wasm/src/words/print.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::{ASCIIData, CharType};
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, signature_from_string, ArgumentCountCheck};
 
@@ -20,7 +21,7 @@ impl ComplexWord for Print {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let value = args.get_expr(0)?;
 

diff --git a/clar2wasm/src/words/responses.rs b/clar2wasm/src/words/responses.rs
@@ -3,6 +3,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ir::BinaryOp;
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{drop_value, ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 pub fn traverse_response(
@@ -53,7 +54,7 @@ impl ComplexWord for IsOk {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         traverse_response(generator, builder, args)
     }
@@ -74,7 +75,7 @@ impl ComplexWord for IsErr {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         traverse_response(generator, builder, args)?;
 

diff --git a/clar2wasm/src/words/secp256k1.rs b/clar2wasm/src/words/secp256k1.rs
@@ -1,6 +1,7 @@
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -19,7 +20,7 @@ impl ComplexWord for Recover {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         generator.traverse_expr(builder, args.get_expr(0)?)?;
         generator.traverse_expr(builder, args.get_expr(1)?)?;
@@ -68,7 +69,7 @@ impl ComplexWord for Verify {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         generator.traverse_expr(builder, args.get_expr(0)?)?;
         generator.traverse_expr(builder, args.get_expr(1)?)?;

diff --git a/clar2wasm/src/words/sequences.rs b/clar2wasm/src/words/sequences.rs
@@ -6,6 +6,7 @@ use clarity::vm::{ClarityName, SymbolicExpression};
 use walrus::ir::{self, BinaryOp, IfElse, InstrSeqType, Loop, UnaryOp};
 use walrus::ValType;
 
+use crate::check_args;
 use crate::error_mapping::ErrorMap;
 use crate::wasm_generator::{
     add_placeholder_for_clarity_type, clar2wasm_ty, drop_value, type_from_sequence_element,
@@ -85,7 +86,7 @@ impl ComplexWord for Fold {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let func = args.get_name(0)?;
         let sequence = args.get_expr(1)?;
@@ -271,7 +272,7 @@ impl ComplexWord for Append {
         expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let ty = generator
             .get_expr_type(expr)
@@ -360,7 +361,7 @@ impl ComplexWord for AsMaxLen {
         _expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         // Push a `0` and a `1` to the stack, to be used by the `select`
         // instruction later.
@@ -462,7 +463,7 @@ impl ComplexWord for Concat {
         expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let memory = generator.get_memory()?;
 
@@ -535,13 +536,13 @@ impl ComplexWord for Map {
         expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             2,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
+            ArgumentCountCheck::AtLeast
+        );
 
         let fname = args.get_name(0)?;
 
@@ -823,7 +824,7 @@ impl ComplexWord for Len {
         _expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         // Traverse the sequence, leaving the offset and length on the stack.
         let seq = args.get_expr(0)?;
@@ -905,7 +906,7 @@ impl ComplexWord for ElementAt {
         expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         // Traverse the sequence, leaving the offset and length on the stack.
         let seq = args.get_expr(0)?;
@@ -1086,7 +1087,7 @@ impl ComplexWord for ReplaceAt {
         expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let seq = args.get_expr(0)?;
         let seq_ty = generator
@@ -1337,7 +1338,7 @@ impl ComplexWord for Slice {
         _expr: &SymbolicExpression,
         args: &[clarity::vm::SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let seq = args.get_expr(0)?;
 

diff --git a/clar2wasm/src/words/stx.rs b/clar2wasm/src/words/stx.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::{ComplexWord, SimpleWord};
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -63,7 +64,7 @@ impl ComplexWord for StxTransfer {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let amount = args.get_expr(0)?;
         let sender = args.get_expr(1)?;
@@ -95,7 +96,7 @@ impl ComplexWord for StxTransferMemo {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 4, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 4, args.len(), ArgumentCountCheck::Exact);
 
         let amount = args.get_expr(0)?;
         let sender = args.get_expr(1)?;

diff --git a/clar2wasm/src/words/tokens.rs b/clar2wasm/src/words/tokens.rs
@@ -2,6 +2,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -20,20 +21,20 @@ impl ComplexWord for DefineFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(
+        check_args!(
             generator,
             builder,
             1,
             args.len(),
-            ArgumentCountCheck::AtLeast,
-        )?;
-        check_argument_count(
+            ArgumentCountCheck::AtLeast
+        );
+        check_args!(
             generator,
             builder,
             2,
             args.len(),
-            ArgumentCountCheck::AtMost,
-        )?;
+            ArgumentCountCheck::AtMost
+        );
 
         let name = args.get_name(0)?;
         // Making sure if name is not reserved
@@ -83,7 +84,7 @@ impl ComplexWord for BurnFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let amount = args.get_expr(1)?;
@@ -121,7 +122,7 @@ impl ComplexWord for TransferFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 4, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 4, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let amount = args.get_expr(1)?;
@@ -161,7 +162,7 @@ impl ComplexWord for MintFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let amount = args.get_expr(1)?;
@@ -198,7 +199,7 @@ impl ComplexWord for GetSupplyOfFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
 
@@ -228,7 +229,7 @@ impl ComplexWord for GetBalanceOfFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let owner = args.get_expr(1)?;
@@ -266,7 +267,7 @@ impl ComplexWord for DefineNonFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let name = args.get_name(0)?;
         // Making sure if name is not reserved
@@ -324,7 +325,7 @@ impl ComplexWord for BurnNonFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let identifier = args.get_expr(1)?;
@@ -378,7 +379,7 @@ impl ComplexWord for TransferNonFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 4, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 4, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let identifier = args.get_expr(1)?;
@@ -436,7 +437,7 @@ impl ComplexWord for MintNonFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 3, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 3, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let identifier = args.get_expr(1)?;
@@ -490,7 +491,7 @@ impl ComplexWord for GetOwnerOfNonFungibleToken {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let token = args.get_name(0)?;
         let identifier = args.get_expr(1)?;

diff --git a/clar2wasm/src/words/traits.rs b/clar2wasm/src/words/traits.rs
@@ -1,6 +1,7 @@
 use clarity::vm::{ClarityName, SymbolicExpression, SymbolicExpressionType};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{ArgumentsExt, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -100,7 +101,7 @@ impl ComplexWord for ImplTrait {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 1, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 1, args.len(), ArgumentCountCheck::Exact);
 
         let trait_identifier = match &args.get_expr(0)?.expr {
             SymbolicExpressionType::Field(trait_identifier) => trait_identifier,

diff --git a/clar2wasm/src/words/tuples.rs b/clar2wasm/src/words/tuples.rs
@@ -4,6 +4,7 @@ use clarity::vm::types::TypeSignature;
 use clarity::vm::{ClarityName, SymbolicExpression};
 
 use super::ComplexWord;
+use crate::check_args;
 use crate::wasm_generator::{clar2wasm_ty, drop_value, GeneratorError, WasmGenerator};
 use crate::wasm_utils::{check_argument_count, ArgumentCountCheck};
 
@@ -111,7 +112,7 @@ impl ComplexWord for TupleGet {
         _expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let target_field_name = args[0]
             .match_atom()
@@ -185,7 +186,7 @@ impl ComplexWord for TupleMerge {
         expr: &SymbolicExpression,
         args: &[SymbolicExpression],
     ) -> Result<(), GeneratorError> {
-        check_argument_count(generator, builder, 2, args.len(), ArgumentCountCheck::Exact)?;
+        check_args!(generator, builder, 2, args.len(), ArgumentCountCheck::Exact);
 
         let lhs_tuple_ty = generator
             .get_expr_type(&args[0])