exit_1 to code/native module

Author: KronicDeth

lumen_runtime/src/otp/erlang.rs

@@ -3,6 +3,8 @@
 pub mod add_2;
 pub mod apply_3;
 pub mod convert_time_unit_3;
+pub mod exit_1;
+pub mod link_1;
 pub mod monotonic_time_0;
 pub mod number_or_badarith_1;
 pub mod self_0;
@@ -38,7 +40,7 @@ use liblumen_alloc::erts::term::{
     Term, Tuple, TypedTerm,
 };
 use liblumen_alloc::erts::ProcessControlBlock;
-use liblumen_alloc::{badarg, badarith, badkey, badmap, error, exit, raise, throw};
+use liblumen_alloc::{badarg, badarith, badkey, badmap, error, raise, throw};
 
 use crate::binary::{start_length_to_part_range, PartRange, ToTermOptions};
 use crate::node;
@@ -822,10 +824,6 @@ pub fn error_2(reason: Term, arguments: Term) -> Result {
     Err(error!(reason, Some(arguments)).into())
 }
 
-pub fn exit_1(reason: Term) -> Result {
-    Err(exit!(reason).into())
-}
-
 pub fn hd_1(list: Term) -> Result {
     let cons: Boxed<Cons> = list.try_into()?;
 

lumen_runtime/src/otp/erlang/exit_1.rs

@@ -0,0 +1,60 @@
+// wasm32 proptest cannot be compiled at the same time as non-wasm32 proptest, so disable tests that
+// use proptest completely for wasm32
+//
+// See https://github.com/rust-lang/cargo/issues/4866
+#[cfg(all(not(target_arch = "wasm32"), test))]
+mod test;
+
+use std::sync::Arc;
+
+use liblumen_alloc::erts::exception;
+use liblumen_alloc::erts::exception::system::Alloc;
+use liblumen_alloc::erts::process::code::stack::frame::{Frame, Placement};
+use liblumen_alloc::erts::process::code::{self, result_from_exception};
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{Atom, Term};
+use liblumen_alloc::{exit, ModuleFunctionArity};
+
+pub fn place_frame_with_arguments(
+    process: &ProcessControlBlock,
+    placement: Placement,
+    reason: Term,
+) -> Result<(), Alloc> {
+    process.stack_push(reason)?;
+    process.place_frame(frame(), placement);
+
+    Ok(())
+}
+
+// Private
+
+fn code(arc_process: &Arc<ProcessControlBlock>) -> code::Result {
+    arc_process.reduce();
+
+    let reason = arc_process.stack_pop().unwrap();
+
+    match native(reason) {
+        Ok(_) => unreachable!(),
+        Err(exception) => result_from_exception(arc_process, exception),
+    }
+}
+
+fn frame() -> Frame {
+    Frame::new(module_function_arity(), code)
+}
+
+fn function() -> Atom {
+    Atom::try_from_str("exit").unwrap()
+}
+
+fn module_function_arity() -> Arc<ModuleFunctionArity> {
+    Arc::new(ModuleFunctionArity {
+        module: super::module(),
+        function: function(),
+        arity: 1,
+    })
+}
+
+fn native(reason: Term) -> exception::Result {
+    Err(exit!(reason).into())
+}

lumen_runtime/src/otp/erlang/tests/exit_1.rs renamed to lumen_runtime/src/otp/erlang/exit_1/test.rs

@@ -1,11 +1,18 @@
-use super::*;
+use proptest::prop_assert_eq;
+use proptest::test_runner::{Config, TestRunner};
+
+use liblumen_alloc::exit;
+
+use crate::otp::erlang::exit_1;
+use crate::scheduler::with_process_arc;
+use crate::test::strategy;
 
 #[test]
 fn exits_with_reason() {
     with_process_arc(|arc_process| {
         TestRunner::new(Config::with_source_file(file!()))
             .run(&strategy::term(arc_process.clone()), |reason| {
-                prop_assert_eq!(erlang::exit_1(reason), Err(exit!(reason).into()));
+                prop_assert_eq!(exit_1::native(reason), Err(exit!(reason).into()));
 
                 Ok(())
             })

lumen_runtime/src/otp/erlang/tests.rs

@@ -58,7 +58,6 @@ mod divide_2;
 mod element_2;
 mod error_1;
 mod error_2;
-mod exit_1;
 mod hd_1;
 mod insert_element_3;
 mod is_alive_0;