add alert pragma to unsafe function (#186)

Co-authored-by: Yorkin <cyb_yorkin@outlook.com>

Author: CAIMEOX

deque/deque.mbt

@@ -191,12 +191,12 @@ pub fn push_back[T](self : Deque[T], value : T) -> Unit {
 
 /// Removes a fornt element from a deque.
 /// 
-/// Panics if the deque is empty.
 /// # Example
 /// ```
 /// let dq = Deque::[1, 2, 3, 4, 5]
 /// dq.pop_front_exn()
 /// ```
+/// @alert unsafe "Panic if the deque is empty."
 pub fn pop_front_exn[T](self : Deque[T]) -> Unit {
   if self.len == 0 {
     abort("The deque is empty!")
@@ -207,12 +207,12 @@ pub fn pop_front_exn[T](self : Deque[T]) -> Unit {
 
 /// Removes a back element from a deque.
 /// 
-/// Panics if the deque is empty.
 /// # Example
 /// ```
 /// let dq = Deque::[1, 2, 3, 4, 5]
 /// dq.pop_back_exn()
 /// ```
+/// @alert unsafe "Panic if the deque is empty."
 pub fn pop_back_exn[T](self : Deque[T]) -> Unit {
   if self.len == 0 {
     abort("The deque is empty!")
@@ -299,6 +299,7 @@ test "push_realloc" {
 /// let dq = Deque::[1, 2, 3, 4, 5]
 /// println(dq[2]) // 3
 /// ```
+/// @alert unsafe "Panic if the index is out of bounds."
 pub fn op_get[T](self : Deque[T], index : Int) -> T {
   if index < 0 || index >= self.len {
     let len = self.len
@@ -337,6 +338,7 @@ test "op_get" {
 /// dq[2] = 1
 /// println(dq[2]) // 1
 /// ```
+/// @alert unsafe "Panic if the index is out of bounds."
 pub fn op_set[T](self : Deque[T], index : Int, value : T) -> Unit {
   if index < 0 || index >= self.len {
     let len = self.len

hashmap/hashmap.mbt

@@ -40,6 +40,7 @@ pub fn HashMap::from_array[K : Hash + Eq, V](
 }
 
 /// Set a key-value pair into hash map.
+/// @alert unsafe "Panic if the hash map is full."
 pub fn set[K : Hash + Eq, V](self : HashMap[K, V], key : K, value : V) -> Unit {
   if self.capacity == 0 || self.size >= self.growAt {
     self.grow()

immutable_set/immutable_set.mbt

@@ -91,6 +91,7 @@ pub fn to_vec[T : Compare](self : ImmutableSet[T]) -> @vec.Vec[T] {
 /// println(ImmutableSet::[3, 4, 5].remove_min())
 /// // output: ImmutableSet::[4, 5]
 /// ```
+/// @alert unsafe "Panic if the ImmutableSet is empty."
 pub fn remove_min[T : Compare](self : ImmutableSet[T]) -> ImmutableSet[T] {
   match self {
     Empty => abort("remove_min: empty ImmutableSet")
@@ -181,6 +182,7 @@ pub fn remove[T : Compare](
 /// println(ImmutableSet::[7, 2, 9, 4, 5, 6, 3, 8, 1].min())
 /// // output: 1
 /// ```
+/// @alert unsafe "Panic if the ImmutableSet is empty."
 pub fn min[T : Compare](self : ImmutableSet[T]) -> T {
   match self {
     Empty => abort("min: there are no values in ImmutableSet.")
@@ -213,6 +215,7 @@ pub fn min_option[T : Compare](self : ImmutableSet[T]) -> Option[T] {
 /// println(ImmutableSet::[7, 2, 9, 4, 5, 6, 3, 8, 1].max())
 /// // output: 9
 /// ```
+/// @alert unsafe "Panic if the ImmutableSet is empty."
 pub fn max[T : Compare](self : ImmutableSet[T]) -> T {
   match self {
     Empty => abort("max: there are no values in ImmutableSet.")

list/list.mbt

@@ -247,6 +247,7 @@ test "tail" {
 /// debug(from_array([1, 2, 3, 4, 5]).head())
 /// // output: 1
 /// ```
+/// @alert unsafe "Panic if the list is empty"
 pub fn head[T](self : List[T]) -> T {
   match self {
     Nil => abort("head of empty list")
@@ -291,6 +292,7 @@ test "head option" {
 /// debug(from_array([1, 2, 3, 4, 5]).last())
 /// // output: 5
 /// ```
+/// @alert unsafe "Panic if the list is empty"
 pub fn last[T](self : List[T]) -> T {
   match self {
     Nil => abort("last of empty list")
@@ -397,10 +399,7 @@ test "fold" {
 /// debug(r) // output: from_array([(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
 /// ```
 /// 
-/// # Panics
-///
-/// If the two lists have different lengths, the function will panic.
-///
+/// @alert unsafe "Panic if the two lists have different lengths."
 pub fn zip[T, U](self : List[T], other : List[U]) -> List[(T, U)] {
   match (self, other) {
     (Nil, Nil) => Nil
@@ -434,6 +433,7 @@ test "concat_map" {
 }
 
 /// Get nth element of the list
+/// @alert unsafe "Panic if the index is out of bounds"
 pub fn nth[T](self : List[T], n : Int) -> T {
   match self {
     Nil => abort("nth: index out of bounds")
@@ -582,6 +582,7 @@ test "flatten" {
 }
 
 /// Get maximum element of the list.
+/// @alert unsafe "Panic if the list is empty"
 pub fn maximum[T : Compare](self : List[T]) -> T {
   match self {
     Nil => abort("maximum: empty list")
@@ -603,6 +604,7 @@ test "maximum" {
 }
 
 /// Get minimum element of the list.
+/// @alert unsafe "Panic if the list is empty"
 pub fn minimum[T : Compare](self : List[T]) -> T {
   match self {
     Nil => abort("minimum: empty list")
@@ -847,6 +849,7 @@ test "lookup" {
 /// println(List::[1, 3, 5, 8].find(fn(element) -> Bool { element % 2 == 0}))
 /// // output: 8
 /// ```
+/// @alert unsafe "Panic if no element satisfies f."
 pub fn find[T](self : List[T], f : (T) -> Bool) -> T {
   match self {
     Nil => abort("find: no matching element")
@@ -900,6 +903,7 @@ test "find_option" {
 /// println(List::[1, 3, 5, 8].findi(fn(element, i) -> Bool { (element % 2 == 0) && (i == 3) }))
 /// // output: 8
 /// ```
+/// @alert unsafe "Panic if no element satisfies f."
 pub fn findi[T](self : List[T], f : (T, Int) -> Bool) -> T {
   fn find(list : List[T], index : Int) -> T {
     match list {

priority_queue/priority_queue.mbt

@@ -102,12 +102,12 @@ test "length" {
 
 /// Pops the first value from the priority queue.
 /// 
-/// Panics if the queue is empty.
 /// # Example
 /// ```
 /// let queue = PriorityQueue::[1, 2, 3, 4]
 /// let first = queue.pop_exn() // 4
 /// ```
+/// @alert unsafe "Panic if the queue is empty."
 pub fn pop_exn[T : Compare](self : PriorityQueue[T]) -> Unit {
   if self.len == 0 {
     abort("The PriorityQueue is empty!")

queue/queue.mbt

@@ -163,12 +163,12 @@ test "push" {
 
 /// Peeks at the first value in the queue.
 /// 
-/// Panics if the queue is empty.
 /// # Example
 /// ```
 /// let queue : Queue[Int] = Queue::[1, 2, 3, 4]
 /// let first = queue.peek_exn()
 /// ```
+/// @alert unsafe "Panics if the queue is empty."
 pub fn peek_exn[T](self : Queue[T]) -> T {
   match self.first {
     Nil => abort("Queue is empty")
@@ -208,12 +208,12 @@ test "peek" {
 
 /// Pops the first value from the queue.
 /// 
-/// Panics if the queue is empty.
 /// # Example
 /// ```
 /// let queue : Queue[Int] = Queue::[1, 2, 3, 4]
 /// let first = queue.pop_exn()
 /// ```
+/// @alert unsafe "Panics if the queue is empty."
 pub fn pop_exn[T](self : Queue[T]) -> T {
   match self.first {
     Nil => abort("Queue is empty")

stack/stack.mbt

@@ -277,6 +277,7 @@ test "pop" {
 /// println(s) // output: { elements: Cons(2, Cons(1, Nil)), len: 2 }
 /// println(s1.pop_exn()) // abort.
 /// ```
+/// @alert unsafe "Panic if the stack is empty."
 pub fn pop_exn[T](self : Stack[T]) -> T {
   match self.elements {
     Cons(hd, tl) => {
@@ -388,6 +389,7 @@ test "peek" {
 /// println(s.peek_exn()) // output: 3
 /// println(s) // output: { elements: Cons(3, Cons(2, Cons(1, Nil))), len: 3 }
 /// ```
+/// @alert unsafe "Panic if the stack is empty."
 pub fn peek_exn[T](self : Stack[T]) -> T {
   match self.elements {
     Cons(hd, _) => hd

vec/vec.mbt

@@ -103,14 +103,13 @@ test "realloc" {
 
 /// Retrieves the element at the specified index from the vector.
 /// 
-/// If you try to access an index which isn’t in the Vec, it will panic.
-/// 
 /// # Example
 /// ```
 /// let v = Vec::new()
 /// v.push(3)
 /// println(v[0]) // 3
 /// ```
+/// @alert unsafe "Panic if index is out of bounds"
 pub fn op_get[T](self : Vec[T], index : Int) -> T {
   if index < 0 || index >= self.len {
     let len = self.len
@@ -123,14 +122,13 @@ pub fn op_get[T](self : Vec[T], index : Int) -> T {
 
 /// Sets the value of the element at the specified index.
 /// 
-/// If you try to access an index which isn’t in the Vec, it will panic.
-/// 
 /// # Example
 /// ```
 /// let v = Vec::new()
 /// v.push(3)
 /// println(v[0]) // 3
 /// ```
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn op_set[T](self : Vec[T], index : Int, value : T) -> Unit {
   if index < 0 || index >= self.len {
     let len = self.len
@@ -237,13 +235,12 @@ test "pop" {
 
 /// Removes the last element from a vector and returns it.
 /// 
-/// Panics if the vector is empty.
-/// 
 /// # Example
 /// ```
 /// let v = Vec::[1, 2, 3]
 /// v.pop_exn() // 3
 /// ```
+/// @alert unsafe "Panic if the vector is empty."
 pub fn pop_exn[T](self : Vec[T]) -> T {
   if self.len == 0 {
     abort("pop from an empty Vec")
@@ -289,13 +286,13 @@ test "push" {
 /// Removes the specified range from the vector and returns it.
 /// 
 /// This functions returns a vector range from `begin` to `end` `[begin, end)`
-/// If you try to access an index which isn’t in the Vec, it will panic.
 /// 
 /// # Example
 /// ```
 /// let v = Vec::[3, 4, 5]
 /// let vv = v.drain(1, 2) // vv = Vec::[4], v = Vec::[3, 5]
 /// ```
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn drain[T](self : Vec[T], begin : Int, end : Int) -> Vec[T] {
   if begin < 0 || begin >= self.len || end < 0 || end > self.len || begin > end {
     let len = self.len
@@ -564,14 +561,13 @@ test "reverse" {
 
 /// Split the vector into two at the given index.
 /// 
-/// If you try to access an index which isn’t in the Vec, it will panic.
-/// 
 /// # Example
 /// ```
 /// let v = Vec::[3, 4, 5]
 /// let (v1, v2) = v.split_at(1)
 /// ```
 /// TODO: perf could be optimized
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn split_at[T](self : Vec[T], index : Int) -> (Vec[T], Vec[T]) {
   if index < 0 || index >= self.len {
     let len = self.len
@@ -761,13 +757,12 @@ test "search" {
 
 /// Swap two elements in the vector.
 /// 
-/// If you try to access an index which isn’t in the Vec, it will panic.
-/// 
 /// # Example
 /// ```
 /// let v = Vec::[3, 4, 5]
 /// v.swap(1, 2)
 /// ```
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn swap[T](self : Vec[T], i : Int, j : Int) -> Unit {
   if i >= self.len || j >= self.len || i < 0 || j < 0 {
     let len = self.len
@@ -797,6 +792,7 @@ test "swap" {
 /// let v = Vec::[3, 4, 5]
 /// v.remove(1)
 /// ```
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn remove[T](self : Vec[T], index : Int) -> T {
   if index < 0 || index >= self.len {
     let len = self.len
@@ -849,6 +845,7 @@ test "retain" {
 /// ```
 /// Vec::[3, 4, 5].resize(1)
 /// ```
+/// @alert unsafe "Panic if new length is negative."
 pub fn resize[T](self : Vec[T], new_len : Int, f : T) -> Unit {
   if new_len < 0 {
     abort("negative new length")
@@ -875,12 +872,11 @@ test "resize" {
 
 /// Inserts an element at a given index within the vector.
 /// 
-/// If you try to access an index which isn’t in the Vec, it will panic.
-/// 
 /// # Example
 /// ```
 /// Vec::[3, 4, 5].insert(1, 6)
 /// ```
+/// @alert unsafe "Panic if index is out of bounds."
 pub fn insert[T](self : Vec[T], index : Int, value : T) -> Unit {
   if index < 0 || index > self.len {
     let len = self.len