From 80fadf8fabc06e457e2d0561233c218bc8529f47 Mon Sep 17 00:00:00 2001
From: ilyalesokhin-starkware <ilya@starkware.co>
Date: Thu, 27 Jun 2024 19:02:49 +0300
Subject: [PATCH] Require destruct instead of drop for unwrapping. (#5902)

---
 corelib/src/option.cairo                      |  8 ++++----
 corelib/src/result.cairo                      | 20 +++++++++----------
 corelib/src/test/circuit_test.cairo           | 17 +++++++---------
 .../src/statement_location_test_data/simple   | 16 +++++++--------
 4 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/corelib/src/option.cairo b/corelib/src/option.cairo
index 6db7b302bb1..9f2a874b147 100644
--- a/corelib/src/option.cairo
+++ b/corelib/src/option.cairo
@@ -22,7 +22,7 @@ pub trait OptionTrait<T> {
     fn unwrap(self: Option<T>) -> T;
     /// Transforms the `Option<T>` into a `Result<T, E>`, mapping `Option::Some(v)` to
     /// `Result::Ok(v)` and `Option::None` to `Result::Err(err)`.
-    fn ok_or<E, +Drop<E>>(self: Option<T>, err: E) -> Result<T, E>;
+    fn ok_or<E, +Destruct<E>>(self: Option<T>, err: E) -> Result<T, E>;
     /// Returns `true` if the `Option` is `Option::Some`.
     #[must_use]
     fn is_some(self: @Option<T>) -> bool;
@@ -30,7 +30,7 @@ pub trait OptionTrait<T> {
     #[must_use]
     fn is_none(self: @Option<T>) -> bool;
     /// If `self` is `Option::Some(x)`, returns `x`. Otherwise, returns the provided default.
-    fn unwrap_or<+Drop<T>>(self: Option<T>, default: T) -> T;
+    fn unwrap_or<+Destruct<T>>(self: Option<T>, default: T) -> T;
     /// If `self` is `Option::Some(x)`, returns `x`. Otherwise, returns `Default::<T>::default()`.
     fn unwrap_or_default<+Default<T>>(self: Option<T>) -> T;
 }
@@ -50,7 +50,7 @@ pub impl OptionTraitImpl<T> of OptionTrait<T> {
     }
 
     #[inline]
-    fn ok_or<E, +Drop<E>>(self: Option<T>, err: E) -> Result<T, E> {
+    fn ok_or<E, +Destruct<E>>(self: Option<T>, err: E) -> Result<T, E> {
         match self {
             Option::Some(v) => Result::Ok(v),
             Option::None => Result::Err(err),
@@ -74,7 +74,7 @@ pub impl OptionTraitImpl<T> of OptionTrait<T> {
     }
 
     #[inline]
-    fn unwrap_or<+Drop<T>>(self: Option<T>, default: T) -> T {
+    fn unwrap_or<+Destruct<T>>(self: Option<T>, default: T) -> T {
         match self {
             Option::Some(x) => x,
             Option::None => default,
diff --git a/corelib/src/result.cairo b/corelib/src/result.cairo
index 5534d7f2533..5c1448adef2 100644
--- a/corelib/src/result.cairo
+++ b/corelib/src/result.cairo
@@ -12,18 +12,18 @@ pub enum Result<T, E> {
 #[generate_trait]
 pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, panics with `err`.
-    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
+    fn expect<+PanicDestruct<E>>(self: Result<T, E>, err: felt252) -> T {
         match self {
             Result::Ok(x) => x,
             Result::Err(_) => core::panic_with_felt252(err),
         }
     }
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, panics.
-    fn unwrap<+Drop<E>>(self: Result<T, E>) -> T {
+    fn unwrap<+Destruct<E>>(self: Result<T, E>) -> T {
         self.expect('Result::unwrap failed.')
     }
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, returns `default`.
-    fn unwrap_or<+Drop<T>, +Drop<E>>(self: Result<T, E>, default: T) -> T {
+    fn unwrap_or<+Destruct<T>, +Destruct<E>>(self: Result<T, E>, default: T) -> T {
         match self {
             Result::Ok(x) => x,
             Result::Err(_) => default,
@@ -31,7 +31,7 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
     /// If `val` is `Result::Ok(x)`, returns `x`.
     /// Otherwise returns `Default::<T>::default()`.
-    fn unwrap_or_default<+Drop<E>, +Default<T>>(self: Result<T, E>) -> T {
+    fn unwrap_or_default<+Destruct<E>, +Default<T>>(self: Result<T, E>) -> T {
         match self {
             Result::Ok(x) => x,
             Result::Err(_) => Default::default(),
@@ -39,14 +39,14 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
 
     /// If `val` is `Result::Err(x)`, returns `x`. Otherwise, panics with `err`.
-    fn expect_err<+Drop<T>>(self: Result<T, E>, err: felt252) -> E {
+    fn expect_err<+PanicDestruct<T>>(self: Result<T, E>, err: felt252) -> E {
         match self {
             Result::Ok(_) => core::panic_with_felt252(err),
             Result::Err(x) => x,
         }
     }
     /// If `val` is `Result::Err(x)`, returns `x`. Otherwise, panics.
-    fn unwrap_err<+Drop<T>>(self: Result<T, E>) -> E {
+    fn unwrap_err<+PanicDestruct<T>>(self: Result<T, E>) -> E {
         self.expect_err('Result::unwrap_err failed.')
     }
     /// Returns `true` if the `Result` is `Result::Ok`.
@@ -67,7 +67,7 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
     /// Returns `true` if the `Result` is `Result::Ok`, and consumes the value.
     #[inline]
-    fn into_is_err<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> bool {
+    fn into_is_err<+Destruct<T>, +Destruct<E>>(self: Result<T, E>) -> bool {
         match self {
             Result::Ok(_) => false,
             Result::Err(_) => true,
@@ -75,7 +75,7 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
     /// Returns `true` if the `Result` is `Result::Err`, and consumes the value.
     #[inline]
-    fn into_is_ok<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> bool {
+    fn into_is_ok<+Destruct<T>, +Destruct<E>>(self: Result<T, E>) -> bool {
         match self {
             Result::Ok(_) => true,
             Result::Err(_) => false,
@@ -96,7 +96,7 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     /// let x: Result<u32, ByteArray> = Result::Err("Nothing here");
     /// assert!(x.ok().is_none());
     /// ```
-    fn ok<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> Option<T> {
+    fn ok<+Destruct<T>, +Destruct<E>>(self: Result<T, E>) -> Option<T> {
         match self {
             Result::Ok(x) => Option::Some(x),
             Result::Err(_) => Option::None,
@@ -117,7 +117,7 @@ pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     /// let x: Result<u32, ByteArray> = Result::Ok(2);
     /// assert!(x.err().is_none());
     /// ```
-    fn err<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> Option<E> {
+    fn err<+Destruct<T>, +Destruct<E>>(self: Result<T, E>) -> Option<E> {
         match self {
             Result::Ok(_) => Option::None,
             Result::Err(x) => Option::Some(x),
diff --git a/corelib/src/test/circuit_test.cairo b/corelib/src/test/circuit_test.cairo
index a5e8e837a3b..5f13610a227 100644
--- a/corelib/src/test/circuit_test.cairo
+++ b/corelib/src/test/circuit_test.cairo
@@ -30,16 +30,13 @@ fn test_circuit_success() {
     let mul = circuit_mul(inv, sub);
 
     let modulus = TryInto::<_, CircuitModulus>::try_into([7, 0, 0, 0]).unwrap();
-    let outputs =
-        match (mul, add, inv)
-            .new_inputs()
-            .next([3, 0, 0, 0])
-            .next([6, 0, 0, 0])
-            .done()
-            .eval(modulus) {
-        Result::Ok(outputs) => { outputs },
-        Result::Err(_) => { panic!("Expected success") }
-    };
+    let outputs = (mul, add, inv)
+        .new_inputs()
+        .next([3, 0, 0, 0])
+        .next([6, 0, 0, 0])
+        .done()
+        .eval(modulus)
+        .unwrap();
 
     assert_eq!(outputs.get_output(add), u384 { limb0: 2, limb1: 0, limb2: 0, limb3: 0 });
     assert_eq!(outputs.get_output(inv), u384 { limb0: 4, limb1: 0, limb2: 0, limb3: 0 });
diff --git a/crates/cairo-lang-sierra-generator/src/statement_location_test_data/simple b/crates/cairo-lang-sierra-generator/src/statement_location_test_data/simple
index a0ad1d474ad..d4682e97d5a 100644
--- a/crates/cairo-lang-sierra-generator/src/statement_location_test_data/simple
+++ b/crates/cairo-lang-sierra-generator/src/statement_location_test_data/simple
@@ -618,8 +618,8 @@ Inlined at:
 In function: lib.cairo::foo
 enum_init<core::panics::PanicResult::<(core::integer::u8,)>, 0>([32]) -> ([33])
 Originating location:
-    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
-                                                               ^
+    fn expect<+PanicDestruct<E>>(self: Result<T, E>, err: felt252) -> T {
+                                                                        ^
 In function: core::result::ResultTraitImpl::expect
 Inlined at:
         u8_overflowing_add(lhs, rhs).expect('u8_add Overflow')
@@ -631,8 +631,8 @@ Inlined at:
 In function: lib.cairo::foo
 store_temp<RangeCheck>([28]) -> ([28])
 Originating location:
-    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
-                                                               ^
+    fn expect<+PanicDestruct<E>>(self: Result<T, E>, err: felt252) -> T {
+                                                                        ^
 In function: core::result::ResultTraitImpl::expect
 Inlined at:
         u8_overflowing_add(lhs, rhs).expect('u8_add Overflow')
@@ -644,8 +644,8 @@ Inlined at:
 In function: lib.cairo::foo
 store_temp<core::panics::PanicResult::<(core::integer::u8,)>>([33]) -> ([33])
 Originating location:
-    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
-                                                               ^
+    fn expect<+PanicDestruct<E>>(self: Result<T, E>, err: felt252) -> T {
+                                                                        ^
 In function: core::result::ResultTraitImpl::expect
 Inlined at:
         u8_overflowing_add(lhs, rhs).expect('u8_add Overflow')
@@ -657,8 +657,8 @@ Inlined at:
 In function: lib.cairo::foo
 return([28], [33])
 Originating location:
-    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
-                                                               ^
+    fn expect<+PanicDestruct<E>>(self: Result<T, E>, err: felt252) -> T {
+                                                                        ^
 In function: core::result::ResultTraitImpl::expect
 Inlined at:
         u8_overflowing_add(lhs, rhs).expect('u8_add Overflow')