feat: add analysis_costs test for handling undefined variable

Author: hstove

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

@@ -706,6 +706,13 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         } else if let Some(type_result) = context.lookup_trait_reference_type(name) {
             Ok(TypeSignature::TraitReferenceType(type_result.clone()))
         } else {
+            // Special case where a top-level is being looked up, which must
+            // be undefined. This early error prevents a cost function error
+            // due to `context.depth` being 0.
+            if context.depth == 0 {
+                return Err(CheckErrors::UndefinedVariable(name.to_string()).into());
+            }
+
             runtime_cost(
                 ClarityCostFunction::AnalysisLookupVariableDepth,
                 self,

stackslib/src/clarity_vm/tests/analysis_costs.rs

@@ -15,13 +15,15 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use clarity::vm::ast::ASTRules;
-use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::clarity::{Error as ClarityError, TransactionConnection};
 use clarity::vm::costs::ExecutionCost;
+use clarity::vm::errors::CheckErrors;
 use clarity::vm::functions::NativeFunctions;
 use clarity::vm::test_util::TEST_HEADER_DB;
 use clarity::vm::tests::{test_only_mainnet_to_chain_id, UnitTestBurnStateDB};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, Value};
 use clarity::vm::{execute as vm_execute, ClarityVersion, ContractName};
+use rstest::rstest;
 use stacks_common::types::chainstate::StacksBlockId;
 use stacks_common::types::StacksEpochId;
 
@@ -304,3 +306,49 @@ fn epoch_205_test_all_mainnet() {
 fn epoch_205_test_all_testnet() {
     epoch_205_test_all(false);
 }
+
+#[rstest]
+#[case(true, StacksEpochId::Epoch21)]
+#[case(true, StacksEpochId::Epoch2_05)]
+#[case(false, StacksEpochId::Epoch21)]
+#[case(false, StacksEpochId::Epoch2_05)]
+fn undefined_top_variable_error(#[case] use_mainnet: bool, #[case] epoch: StacksEpochId) {
+    let mut clarity_instance =
+        setup_tracked_cost_test(use_mainnet, epoch, ClarityVersion::Clarity1);
+    let contract_self = "foo";
+
+    let self_contract_id =
+        QualifiedContractIdentifier::local("undefined-top-variable-error").unwrap();
+
+    let burn_state_db = UnitTestBurnStateDB {
+        epoch_id: epoch,
+        ast_rules: ASTRules::PrecheckSize,
+    };
+
+    {
+        let mut conn = clarity_instance.begin_block(
+            &StacksBlockId([3; 32]),
+            &StacksBlockId([4; 32]),
+            &TEST_HEADER_DB,
+            &burn_state_db,
+        );
+
+        conn.as_transaction(|conn| {
+            let analysis_result = conn.analyze_smart_contract(
+                &self_contract_id,
+                ClarityVersion::Clarity1,
+                &contract_self,
+                ASTRules::PrecheckSize,
+            );
+            let Err(ClarityError::Analysis(check_error)) = analysis_result else {
+                panic!("Bad analysis result: {:?}", &analysis_result);
+            };
+            let CheckErrors::UndefinedVariable(var_name) = check_error.err else {
+                panic!("Bad analysis error: {:?}", &check_error);
+            };
+            assert_eq!(var_name, "foo".to_string());
+        });
+
+        conn.commit_block();
+    }
+}