refact(core): add runtime_error and use where appropriate

Thus, there are three levels of errors in Rivet:

    - runtime error: This arises when an error occurs during some
      operation in the `core` module, for example a null pointer
      dereference. The exit code for this is 100.

    - panic: This occurs when something unexpected happens and there
      is no way to fix it, such as modifying a non-existent text file.
      The code for this is 101.

    - unhandled error: This occurs when an error is thrown and is not
      handled. The code for this is 102.

Author: StunxFS

lib/core/src/StringFormatter.ri

@@ -26,7 +26,7 @@ pub struct StringFormatter {
                         arg_idx := args_idx;
                         args_idx += 1;
                         if arg_idx >= args.len {
-                            process_panic(
+                            runtime_error(
                                 "string.fmt(): argument index out of range (argument index: {}, len: {}) at index {}",
                                 arg_idx, args.len, self.i
                             );
@@ -59,15 +59,15 @@ pub struct StringFormatter {
                             buf.push(unsafe { self.buf.ptr[self.i] });
                             self.i += 1;
                             if self.i >= self.buf.len {
-                                process_panic(
+                                runtime_error(
                                     "string.fmt(): incomplete format string at index {}",
                                     start
                                 );
                             }
                         }
                         index := buf.as_uint64();
                         if index >= args.len {
-                            process_panic(
+                            runtime_error(
                                 "string.fmt(): argument index out of range (index: {}, len: {})",
                                 index, args.len
                             );
@@ -89,7 +89,7 @@ pub struct StringFormatter {
                             }
                         }
                     } else {
-                        process_panic(
+                        runtime_error(
                             "string.fmt(): expecting closing `}}` in format string at index {}",
                             self.i
                         );
@@ -100,7 +100,7 @@ pub struct StringFormatter {
                         self.res.write_byte(b'}');
                         self.i += 1;
                     } else {
-                        process_panic(
+                        runtime_error(
                             "string.fmt(): single `}}` encountered in format string at index {}",
                             self.i
                         );
@@ -123,12 +123,12 @@ pub struct StringFormatter {
             buf.push(unsafe { self.buf.ptr[self.i] });
             self.i += 1;
             if self.i >= self.buf.len {
-                process_panic("string.fmt(): incomplete format string (index: {})", start);
+                runtime_error("string.fmt(): incomplete format string (index: {})", start);
             }
         }
         fwidth := buf.as_int();
         if fwidth == 0 {
-            process_panic(
+            runtime_error(
                 "string.fmt(): invalid width value (cannot be 0 and cannot be omitted) -> (index: {})",
                 start
             );

lib/core/src/Vector.c.ri

@@ -39,14 +39,14 @@ struct Vector {
 
     func get(self, idx: uint) -> rawptr {
         if idx >= self.len {
-            process_panic("vector index out of range (index: {}, len: {})", idx, self.len);
+            runtime_error("vector index out of range (index: {}, len: {})", idx, self.len);
         }
         return unsafe { @ptr_add(@as([&]mut uint8, self.ptr), idx * self.elem_size) };
     }
 
     func set(self, idx: uint, val: rawptr) {
         if idx >= self.len {
-            process_panic("vector index out of range (index: {}, len: {})", idx, self.len);
+            runtime_error("vector index out of range (index: {}, len: {})", idx, self.len);
         }
         unsafe {
             mem_copy(
@@ -70,7 +70,7 @@ struct Vector {
     /// vector is empty, this will panic.
     func pop(mut self) -> rawptr {
         if self.len == 0 {
-            process_panic("Vec.pop: vector is empty");
+            runtime_error("Vec.pop: vector is empty");
         }
         new_len := self.len - 1;
         self.len = new_len;
@@ -84,8 +84,8 @@ struct Vector {
     pub func delete(mut self, i: uint, size: uint := 1, no_slices: bool := false) {
         if i + size > self.len {
             end_idx := if size == 1 { "..{}".fmt(i + size) } else { "" };
-            process_panic(
-                "Vector.delete(): index out of range (i: {}{}, self.len: {})",
+            runtime_error(
+                "Vector.delete(): index out of range (i: {}..{}, self.len: {})",
                 i, end_idx, self.len
             );
         }
@@ -156,7 +156,7 @@ struct Vector {
 
     func slice(self, start: uint, end: uint) -> Self {
         if start > end or end > self.len {
-            process_panic(
+            runtime_error(
                 "slice index out of range (range: {}..{}, len: {})", start, end, self.len
             );
         }

lib/core/src/array.c.ri

@@ -6,7 +6,7 @@ import c/libc;
 
 func array_index(len: uint, idx: uint) {
     if idx >= len {
-        process_panic("array index out of range (index: {}, size: {})", idx, len);
+        runtime_error("array index out of range (index: {}, size: {})", idx, len);
     }
 }
 
@@ -22,7 +22,7 @@ func array_ne(arr: rawptr, other_arr: rawptr, len: uint) -> bool {
 
 func array_slice(arr: rawptr, elem_size: uint, size: uint, start: uint, end: uint) -> Vector {
     if start > end or end > size {
-        process_panic("slice index out of range (range: {}..{}, len: {})", start, end, size);
+        runtime_error("slice index out of range (range: {}..{}, len: {})", start, end, size);
     }
     len := end - start;
     return unsafe {

lib/core/src/entry_point.ri

@@ -30,17 +30,20 @@ func main(
 ) {
     setup_signals_handler();
     init_args(@as(uint, _argc), _argv);
+
 #if !_TESTS_ // `init_string_lits` is called after
     init_string_lits();
 #endif
     init_globals();
     libcoreIsStarted = true;
+
 #if _TESTS_
     if test_runner.tests.len > 0 {
         test_runner.run();
     }
 #else
     mod_main();
 #endif
+
     drop_globals();
 }

lib/core/src/errors.ri

@@ -30,7 +30,7 @@ struct ReturnTrace {
     #[inline]
     func add(mut self, trace: CallTrace) {
         if self.cur_idx == RETURN_TRACE_MAX_SIZE {
-            process_panic("maximum return trace size exceeded");
+            runtime_error("maximum return trace size exceeded");
         }
         self.traces[self.cur_idx] = trace;
         self.cur_idx += 1;

lib/core/src/lib.ri

@@ -4,14 +4,6 @@
 
 var mut libcoreIsStarted := false;
 
-func panic_if(cond: bool, msg: string) {
-    if cond {
-        console_ewriteln("panic: {}", msg);
-        bt_print(2);
-        process_exit(1);
-    }
-}
-
 func assert(cond: bool, msg: string) {
     if !cond {
         console_ewriteln("panic: assertion failed: {}", msg);
@@ -20,10 +12,16 @@ func assert(cond: bool, msg: string) {
     }
 }
 
+func runtime_error(s: string, args: ...Stringable) -> never {
+    console_ewriteln("runtime error: {}", s.fmt(args));
+    bt_print(2);
+    process_exit(100);
+}
+
 #[inline]
 func internal_alloc(size: uint) -> rawptr {
     return mem_alloc(size) catch {
-        process_panic(
+        runtime_error(
             "internal error: cannot allocate memory" #if _DEBUG_ " (size: {})", size #endif
         )
     };
@@ -32,7 +30,7 @@ func internal_alloc(size: uint) -> rawptr {
 #[inline]
 func internal_zeroed(size: uint) -> rawptr {
     return mem_zeroed(size) catch {
-        process_panic(
+        runtime_error(
             "internal error: cannot allocate zeroed memory" #if _DEBUG_ " (size: {})", size #endif
         )
     };
@@ -41,7 +39,7 @@ func internal_zeroed(size: uint) -> rawptr {
 #[inline]
 func internal_dup(src: rawptr, sz: uint) -> rawptr {
     return mem_dup(src, sz) catch {
-        process_panic(
+        runtime_error(
             "internal error: cannot duplicate memory" #if _DEBUG_ " (size: {})", sz #endif
         )
     };
@@ -50,7 +48,7 @@ func internal_dup(src: rawptr, sz: uint) -> rawptr {
 #[inline]
 func internal_resize(ptr: ?rawptr, sz: uint) -> rawptr {
     return mem_resize(ptr, sz) catch {
-        process_panic(
+        runtime_error(
             "internal error: cannot resize memory" #if _DEBUG_ " (size: {})", sz #endif
         )
     };

lib/core/src/rune.c.ri

@@ -38,11 +38,11 @@ extend rune < Stringable {
     /// Panics if given a radix larger than 36.
     pub func from_digit(num: uint32, radix: uint32) -> ?rune {
         if radix > 36 {
-            process_panic("rune.from_digit: radix is too high (maximum 36)");
+            runtime_error("rune.from_digit: radix is too high (maximum 36)");
         }
         if num < radix {
             num_ := @as(uint8, num);
-            byte := (if num_ < 10 { b'0' + num_ } else { b'a' + num_ - 10 });
+            byte := if num_ < 10 { b'0' + num_ } else { b'a' + num_ - 10 };
             return byte.to_rune();
         }
         return none;

lib/core/src/signals.c.ri

@@ -26,23 +26,23 @@ func signals_handler(_sig: int32, info: &mut libc.siginfo_t, _context: rawptr) {
 func segfault_handler() {
     console_ewriteln(
         if libcoreIsStarted {
-            "panic: invalid memory address or null pointer dereference"
+            "runtime error: invalid memory address or null pointer dereference"
         } else {
-            "panic: invalid memory address or null pointer dereference while starting the core"
+            "runtime error: invalid memory address or null pointer dereference while starting the core"
         }
     );
     bt_print(4);
-    process_exit(1);
+    process_exit(100);
 }
 
 func fpe_handler() {
     console_ewriteln(
         if libcoreIsStarted {
-            "panic: floating point exception"
+            "runtime error: floating point exception"
         } else {
-            "panic: floating point exception while starting the core"
+            "runtime error: floating point exception while starting the core"
         }
     );
     bt_print(4);
-    process_exit(1);
+    process_exit(100);
 }

lib/core/src/string.c.ri

@@ -29,7 +29,7 @@ pub struct string < Stringable, Hashable, Throwable {
         }
         return if safe_ptr := ptr {
             if unsafe { safe_ptr[len] != 0 } {
-                process_panic("`ptr` is not a valid string, doesn't ends with NLL byte");
+                runtime_error("`ptr` is not a valid string, doesn't ends with NLL byte");
             }
             Self(safe_ptr, len, is_ref)
         } else {
@@ -62,7 +62,7 @@ pub struct string < Stringable, Hashable, Throwable {
 
     pub func at(self, idx: uint) -> uint8 {
         if idx >= self.len {
-            process_panic("string index out of range (index: {}, len: {})", idx, self.len);
+            runtime_error("string index out of range (index: {}, len: {})", idx, self.len);
         }
         return unsafe { self.ptr[idx] };
     }
@@ -788,7 +788,7 @@ pub struct string < Stringable, Hashable, Throwable {
     func slice(self, start: uint, end: uint) -> Self {
         unsafe {
             if start > end or start > self.len or end > self.len {
-                process_panic(
+                runtime_error(
                     "string slice index out of range (range: {}..{}, len: {})", start,
                     end, self.len
                 );

lib/core/src/utils.c.ri

@@ -13,7 +13,7 @@ func enum_cast(ptr: rawptr, expected_id: uint) -> rawptr {
     if enum_info._id_ != expected_id {
         // TODO: replace indexes with names
         console_ewriteln(
-            "panic: enum cast: cannot cast ID({}) to ID({})", enum_info._id_, expected_id
+            "runtime error: enum cast: cannot cast ID({}) to ID({})", enum_info._id_, expected_id
         );
         bt_print(2);
         process_exit(1);
@@ -25,7 +25,7 @@ func trait_cast(got_obj: rawptr, got_id: uint, expected_id: uint) -> rawptr {
     if got_id != expected_id {
         // TODO: replace indexes with names
         console_ewriteln(
-            "panic: trait cast: cannot cast ID({}) to ID({})", got_id, expected_id
+            "runtime error: trait cast: cannot cast ID({}) to ID({})", got_id, expected_id
         );
         bt_print(2);
         process_exit(1);

rivetc/src/codegen/__init__.py

@@ -982,7 +982,7 @@ def gen_expr(self, expr, custom_tmp = None):
                      self.gen_expr(expr.args[1])]
                 )
             elif expr.name == "unreachable":
-                self.panic("entered unreachable code")
+                self.runtime_error("entered unreachable code")
             elif expr.name == "breakpoint" and self.comp.prefs.build_mode != prefs.BuildMode.Release:
                 self.cur_fn.breakpoint()
         elif isinstance(expr, ast.TupleLiteral):
@@ -2620,6 +2620,14 @@ def option_none(self, typ):
         )
         return tmp
 
+    def runtime_error(self, msg):
+        self.cur_fn.add_call(
+            "_R4core13runtime_errorF", [
+                self.gen_string_literal(utils.smart_quote(msg, False)),
+                self.empty_vec(self.comp.universe["[]core.Stringable"])
+            ]
+        )
+
     def panic(self, msg):
         self.cur_fn.add_call(
             "_R4core13process_panicF", [