Merge pull request #6502 from jferrant/chore/aac-rename-short-return-type

Chore/aac rename short return type

Author: jferrant

clarity-types/src/errors/mod.rs

@@ -46,7 +46,7 @@ pub enum Error {
     Unchecked(CheckErrors),
     Interpreter(InterpreterError),
     Runtime(RuntimeErrorType, Option<StackTrace>),
-    ShortReturn(ShortReturnType),
+    EarlyReturn(EarlyReturnError),
 }
 
 /// InterpreterErrors are errors that *should never* occur.
@@ -104,8 +104,15 @@ pub enum RuntimeErrorType {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum ShortReturnType {
-    ExpectedValue(Box<Value>),
+/// Errors triggered during Clarity contract evaluation that cause early termination.
+/// These errors halt evaluation and fail the transaction.
+pub enum EarlyReturnError {
+    /// Failed to unwrap an `Optional` (`none`) or `Response` (`err` or `ok`) Clarity value.
+    /// The `Box<Value>` holds the original or thrown value. Triggered by `try!`, `unwrap-or`, or
+    /// `unwrap-err-or`.
+    UnwrapFailed(Box<Value>),
+    /// An 'asserts!' expression evaluated to false.
+    /// The `Box<Value>` holds the value provided as the second argument to `asserts!`.
     AssertionFailed(Box<Value>),
 }
 
@@ -122,7 +129,7 @@ impl PartialEq<Error> for Error {
         match (self, other) {
             (Error::Runtime(x, _), Error::Runtime(y, _)) => x == y,
             (Error::Unchecked(x), Error::Unchecked(y)) => x == y,
-            (Error::ShortReturn(x), Error::ShortReturn(y)) => x == y,
+            (Error::EarlyReturn(x), Error::EarlyReturn(y)) => x == y,
             (Error::Interpreter(x), Error::Interpreter(y)) => x == y,
             _ => false,
         }
@@ -208,9 +215,9 @@ impl From<(CheckErrors, &SymbolicExpression)> for Error {
     }
 }
 
-impl From<ShortReturnType> for Error {
-    fn from(err: ShortReturnType) -> Self {
-        Error::ShortReturn(err)
+impl From<EarlyReturnError> for Error {
+    fn from(err: EarlyReturnError) -> Self {
+        Error::EarlyReturn(err)
     }
 }
 
@@ -225,11 +232,11 @@ impl From<Error> for () {
     fn from(_err: Error) -> Self {}
 }
 
-impl From<ShortReturnType> for Value {
-    fn from(val: ShortReturnType) -> Self {
+impl From<EarlyReturnError> for Value {
+    fn from(val: EarlyReturnError) -> Self {
         match val {
-            ShortReturnType::ExpectedValue(v) => *v,
-            ShortReturnType::AssertionFailed(v) => *v,
+            EarlyReturnError::UnwrapFailed(v) => *v,
+            EarlyReturnError::AssertionFailed(v) => *v,
         }
     }
 }
@@ -241,15 +248,15 @@ mod test {
     #[test]
     fn equality() {
         assert_eq!(
-            Error::ShortReturn(ShortReturnType::ExpectedValue(Box::new(Value::Bool(true)))),
-            Error::ShortReturn(ShortReturnType::ExpectedValue(Box::new(Value::Bool(true))))
+            Error::EarlyReturn(EarlyReturnError::UnwrapFailed(Box::new(Value::Bool(true)))),
+            Error::EarlyReturn(EarlyReturnError::UnwrapFailed(Box::new(Value::Bool(true))))
         );
         assert_eq!(
             Error::Interpreter(InterpreterError::InterpreterError("".to_string())),
             Error::Interpreter(InterpreterError::InterpreterError("".to_string()))
         );
         assert!(
-            Error::ShortReturn(ShortReturnType::ExpectedValue(Box::new(Value::Bool(true))))
+            Error::EarlyReturn(EarlyReturnError::UnwrapFailed(Box::new(Value::Bool(true))))
                 != Error::Interpreter(InterpreterError::InterpreterError("".to_string()))
         );
     }

clarity/src/vm/callables.rs

@@ -294,7 +294,7 @@ impl DefinedFunction {
         match result {
             Ok(r) => Ok(r),
             Err(e) => match e {
-                Error::ShortReturn(v) => Ok(v.into()),
+                Error::EarlyReturn(v) => Ok(v.into()),
                 _ => Err(e),
             },
         }

clarity/src/vm/errors.rs

@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 pub use clarity_types::errors::{
-    Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType,
-    ShortReturnType,
+    EarlyReturnError, Error, IncomparableError, InterpreterError, InterpreterResult,
+    RuntimeErrorType,
 };
 
 pub use crate::vm::analysis::errors::{

clarity/src/vm/functions/mod.rs

@@ -20,8 +20,8 @@ use crate::vm::callables::{cost_input_sized_vararg, CallableType, NativeHandle};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{constants as cost_constants, runtime_cost, CostTracker, MemoryConsumer};
 use crate::vm::errors::{
-    check_argument_count, check_arguments_at_least, CheckErrors, Error,
-    InterpreterResult as Result, ShortReturnType, SyntaxBindingError, SyntaxBindingErrorType,
+    check_argument_count, check_arguments_at_least, CheckErrors, EarlyReturnError, Error,
+    InterpreterResult as Result, SyntaxBindingError, SyntaxBindingErrorType,
 };
 pub use crate::vm::functions::assets::stx_transfer_consolidated;
 use crate::vm::representations::{ClarityName, SymbolicExpression, SymbolicExpressionType};
@@ -667,7 +667,7 @@ fn special_asserts(
                 Ok(conditional)
             } else {
                 let thrown = eval(&args[1], env, context)?;
-                Err(ShortReturnType::AssertionFailed(Box::new(thrown)).into())
+                Err(EarlyReturnError::AssertionFailed(Box::new(thrown)).into())
             }
         }
         _ => Err(CheckErrors::TypeValueError(

clarity/src/vm/functions/options.rs

@@ -18,8 +18,8 @@ use crate::vm::contexts::{Environment, LocalContext};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{runtime_cost, CostTracker, MemoryConsumer};
 use crate::vm::errors::{
-    check_arguments_at_least, CheckErrors, InterpreterError, InterpreterResult as Result,
-    RuntimeErrorType, ShortReturnType,
+    check_arguments_at_least, CheckErrors, EarlyReturnError, InterpreterError,
+    InterpreterResult as Result, RuntimeErrorType,
 };
 use crate::vm::types::{CallableData, OptionalData, ResponseData, TypeSignature, Value};
 use crate::vm::Value::CallableContract;
@@ -66,7 +66,7 @@ pub fn native_unwrap(input: Value) -> Result<Value> {
 pub fn native_unwrap_or_ret(input: Value, thrown: Value) -> Result<Value> {
     inner_unwrap(input).and_then(|opt_value| match opt_value {
         Some(v) => Ok(v),
-        None => Err(ShortReturnType::ExpectedValue(Box::new(thrown)).into()),
+        None => Err(EarlyReturnError::UnwrapFailed(Box::new(thrown)).into()),
     })
 }
 
@@ -80,15 +80,15 @@ pub fn native_unwrap_err(input: Value) -> Result<Value> {
 pub fn native_unwrap_err_or_ret(input: Value, thrown: Value) -> Result<Value> {
     inner_unwrap_err(input).and_then(|opt_value| match opt_value {
         Some(v) => Ok(v),
-        None => Err(ShortReturnType::ExpectedValue(Box::new(thrown)).into()),
+        None => Err(EarlyReturnError::UnwrapFailed(Box::new(thrown)).into()),
     })
 }
 
 pub fn native_try_ret(input: Value) -> Result<Value> {
     match input {
         Value::Optional(data) => match data.data {
             Some(data) => Ok(*data),
-            None => Err(ShortReturnType::ExpectedValue(Box::new(Value::none())).into()),
+            None => Err(EarlyReturnError::UnwrapFailed(Box::new(Value::none())).into()),
         },
         Value::Response(data) => {
             if data.committed {
@@ -99,7 +99,7 @@ pub fn native_try_ret(input: Value) -> Result<Value> {
                         "BUG: Failed to construct new response type from old response type".into(),
                     )
                 })?;
-                Err(ShortReturnType::ExpectedValue(Box::new(short_return_val)).into())
+                Err(EarlyReturnError::UnwrapFailed(Box::new(short_return_val)).into())
             }
         }
         _ => Err(CheckErrors::ExpectedOptionalOrResponseValue(Box::new(input)).into()),

clarity/src/vm/tests/datamaps.rs

@@ -16,7 +16,7 @@
 use crate::vm::types::{TupleData, Value};
 #[cfg(test)]
 use crate::vm::{
-    errors::{CheckErrors, ShortReturnType, SyntaxBindingError},
+    errors::{CheckErrors, EarlyReturnError, SyntaxBindingError},
     types::{ListData, SequenceData, TupleTypeSignature, TypeSignature},
 };
 use crate::vm::{execute, ClarityName, Error};
@@ -296,7 +296,7 @@ fn test_set_response_variable() {
     "#;
     let contract_src = contract_src.to_string();
     assert_eq!(
-        Err(ShortReturnType::ExpectedValue(Box::new(Value::Int(5))).into()),
+        Err(EarlyReturnError::UnwrapFailed(Box::new(Value::Int(5))).into()),
         execute(&contract_src)
     );
 }

clarity/src/vm/tests/simple_apply_eval.rs

@@ -31,7 +31,7 @@ use crate::vm::callables::DefinedFunction;
 use crate::vm::contexts::OwnedEnvironment;
 use crate::vm::costs::LimitedCostTracker;
 use crate::vm::database::MemoryBackingStore;
-use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType, ShortReturnType};
+use crate::vm::errors::{CheckErrors, EarlyReturnError, Error, RuntimeErrorType};
 use crate::vm::tests::{execute, test_clarity_versions};
 use crate::vm::types::signatures::*;
 use crate::vm::types::{
@@ -1431,7 +1431,7 @@ fn test_option_destructs() {
                 .into(),
         ),
         Ok(Value::Int(3)),
-        Err(ShortReturnType::ExpectedValue(Box::new(Value::Int(2))).into()),
+        Err(EarlyReturnError::UnwrapFailed(Box::new(Value::Int(2))).into()),
         Ok(Value::Int(3)),
         Ok(Value::Int(3)),
         Ok(Value::Int(3)),
@@ -1444,9 +1444,9 @@ fn test_option_destructs() {
         Ok(Value::Int(8)),
         Err(CheckErrors::BadMatchInput(Box::new(TypeSignature::IntType)).into()),
         Err(CheckErrors::BadMatchInput(Box::new(TypeSignature::IntType)).into()),
-        Err(ShortReturnType::ExpectedValue(Box::new(Value::error(Value::UInt(1)).unwrap())).into()),
+        Err(EarlyReturnError::UnwrapFailed(Box::new(Value::error(Value::UInt(1)).unwrap())).into()),
         Ok(Value::Int(3)),
-        Err(ShortReturnType::ExpectedValue(Box::new(Value::none())).into()),
+        Err(EarlyReturnError::UnwrapFailed(Box::new(Value::none())).into()),
         Ok(Value::Bool(true)),
         Err(CheckErrors::IncorrectArgumentCount(1, 2).into()),
         Err(CheckErrors::ExpectedOptionalOrResponseValue(Box::new(Value::Int(1))).into()),
@@ -1675,10 +1675,10 @@ fn test_asserts_short_circuit() {
     ];
 
     let expectations: &[Error] = &[
-        Error::ShortReturn(ShortReturnType::AssertionFailed(Box::new(
+        Error::EarlyReturn(EarlyReturnError::AssertionFailed(Box::new(
             Value::error(Value::Int(0)).unwrap(),
         ))),
-        Error::ShortReturn(ShortReturnType::AssertionFailed(Box::new(
+        Error::EarlyReturn(EarlyReturnError::AssertionFailed(Box::new(
             Value::error(Value::Int(1)).unwrap(),
         ))),
     ];

stackslib/src/chainstate/stacks/db/transactions.rs

@@ -382,7 +382,7 @@ pub fn handle_clarity_runtime_error(error: clarity_error) -> ClarityRuntimeTxErr
                 err_type: "runtime error",
             }
         }
-        clarity_error::Interpreter(InterpreterError::ShortReturn(_)) => {
+        clarity_error::Interpreter(InterpreterError::EarlyReturn(_)) => {
             ClarityRuntimeTxError::Acceptable {
                 error,
                 err_type: "short return/panic",