:erlang.spawn_link/3

Author: KronicDeth

liblumen_alloc/src/erts/term/term.rs

@@ -938,6 +938,15 @@ impl Term {
         typecheck::is_list(self.0)
     }
 
+    pub fn is_proper_list(&self) -> bool {
+        self.is_nil()
+            || (self.is_non_empty_list() && {
+                let cons: Boxed<Cons> = (*self).try_into().unwrap();
+
+                cons.is_proper()
+            })
+    }
+
     /// Returns true if this a term that the runtime should accept as an argument.
     pub fn is_runtime(&self) -> bool {
         self.is_immediate() || self.is_boxed() || self.is_non_empty_list()

liblumen_eir_interpreter/src/lib.rs

@@ -8,6 +8,7 @@ use liblumen_alloc::erts::process::{heap, next_heap_size, Status};
 use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term};
 use liblumen_alloc::erts::ModuleFunctionArity;
 
+use lumen_runtime::process::Linkage;
 use lumen_runtime::scheduler::Scheduler;
 use lumen_runtime::system;
 
@@ -66,8 +67,9 @@ pub fn call_erlang(
     // if this fails the entire tab is out-of-memory
     let heap = heap(heap_size).unwrap();
 
-    let run_arc_process = Scheduler::spawn_apply_3(
+    let run_arc_process = Scheduler::spawn_linkage_apply_3(
         &proc,
+        Linkage::None,
         module,
         function,
         arguments,

liblumen_eir_interpreter/src/vm.rs

@@ -6,6 +6,8 @@ use libeir_ir::FunctionIdent;
 use liblumen_alloc::erts::exception;
 use liblumen_alloc::erts::process::{heap, next_heap_size, Status};
 use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term};
+
+use lumen_runtime::process::Linkage;
 use lumen_runtime::scheduler::Scheduler;
 use lumen_runtime::system;
 
@@ -48,8 +50,9 @@ impl VMState {
         // if this fails the entire tab is out-of-memory
         let heap = heap(heap_size).unwrap();
 
-        let run_arc_process = Scheduler::spawn_apply_3(
+        let run_arc_process = Scheduler::spawn_linkage_apply_3(
             &init_arc_process,
+            Linkage::None,
             module,
             function,
             arguments,

lumen_runtime/src/otp/erlang.rs

@@ -11,6 +11,8 @@ pub mod process_flag_2;
 pub mod self_0;
 pub mod send_2;
 pub mod spawn_3;
+pub mod spawn_link_3;
+pub mod spawn_linkage_3;
 pub mod subtract_2;
 pub mod unlink_1;
 

lumen_runtime/src/otp/erlang/link_1/test/with_local_pid.rs

@@ -69,7 +69,7 @@ fn with_existing_linked_pid_returns_true() {
 }
 
 #[test]
-fn when_a_linked_process_exits_the_process_exits_too() {
+fn when_a_linked_process_exits_normal_the_process_does_not_exit() {
     with_process(|process| {
         let other_arc_process = process::test(process);
 
@@ -92,13 +92,101 @@ fn when_a_linked_process_exits_the_process_exits_too() {
 
         assert!(Scheduler::current().run_through(&other_arc_process));
 
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting())
+    });
+}
+
+#[test]
+fn when_a_linked_process_exits_shutdown_the_process_does_not_exit() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        assert_eq!(
+            native(process, other_arc_process.pid_term()),
+            Ok(true.into())
+        );
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        erlang::exit_1::place_frame_with_arguments(
+            &other_arc_process,
+            Placement::Replace,
+            atom_unchecked("shutdown"),
+        )
+        .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting())
+    });
+}
+
+#[test]
+fn when_a_linked_process_exits_with_shutdown_tuple_the_process_does_not_exit() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        assert_eq!(
+            native(process, other_arc_process.pid_term()),
+            Ok(true.into())
+        );
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        let tag = atom_unchecked("shutdown");
+        let shutdown_reason = atom_unchecked("test");
+        let reason = other_arc_process
+            .tuple_from_slice(&[tag, shutdown_reason])
+            .unwrap();
+        erlang::exit_1::place_frame_with_arguments(&other_arc_process, Placement::Replace, reason)
+            .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting())
+    });
+}
+
+#[test]
+fn when_a_linked_process_exits_unexpected_the_process_does_not_exit() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        assert_eq!(
+            native(process, other_arc_process.pid_term()),
+            Ok(true.into())
+        );
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        erlang::exit_1::place_frame_with_arguments(
+            &other_arc_process,
+            Placement::Replace,
+            atom_unchecked("abnormal"),
+        )
+        .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
         assert!(other_arc_process.is_exiting());
         assert!(process.is_exiting())
     });
 }
 
 #[test]
-fn when_the_process_exits_linked_processes_exit_too() {
+fn when_the_process_exits_unexpected_linked_processes_exit_too() {
     with_process_arc(|arc_process| {
         let other_arc_process = process::test(&arc_process);
 
@@ -115,7 +203,7 @@ fn when_the_process_exits_linked_processes_exit_too() {
         erlang::exit_1::place_frame_with_arguments(
             &arc_process,
             Placement::Replace,
-            atom_unchecked("normal"),
+            atom_unchecked("abnormal"),
         )
         .unwrap();
 

lumen_runtime/src/otp/erlang/process_flag_2/test/with_atom_flag/with_trap_exit_flag.rs

@@ -6,7 +6,7 @@ use liblumen_alloc::erts::term::{atom_unchecked, Term};
 use crate::otp::erlang;
 use crate::process;
 use crate::scheduler::Scheduler;
-use crate::test::has_message;
+use crate::test::{has_message, has_no_message};
 
 #[test]
 fn without_boolean_value_errors_badarg() {
@@ -53,6 +53,91 @@ fn with_true_value_then_boolean_value_returns_old_value_true() {
         .unwrap();
 }
 
+#[test]
+fn with_true_value_with_linked_and_does_not_exit_when_linked_process_exits_normal() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        process.link(&other_arc_process);
+
+        assert_eq!(native(process, flag(), true.into()), Ok(false.into()));
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        let reason = atom_unchecked("normal");
+
+        erlang::exit_1::place_frame_with_arguments(&other_arc_process, Placement::Replace, reason)
+            .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+        assert!(has_no_message(process));
+    });
+}
+
+#[test]
+fn with_true_value_with_linked_and_does_not_exit_when_linked_process_exits_shutdown() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        process.link(&other_arc_process);
+
+        assert_eq!(native(process, flag(), true.into()), Ok(false.into()));
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        let reason = atom_unchecked("shutdown");
+
+        erlang::exit_1::place_frame_with_arguments(&other_arc_process, Placement::Replace, reason)
+            .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+        assert!(has_no_message(process));
+    });
+}
+
+#[test]
+fn with_true_value_with_linked_and_does_not_exit_when_linked_process_exits_with_shutdown_tuple() {
+    with_process(|process| {
+        let other_arc_process = process::test(process);
+
+        process.link(&other_arc_process);
+
+        assert_eq!(native(process, flag(), true.into()), Ok(false.into()));
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(!other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+
+        let tag = atom_unchecked("shutdown");
+        let shutdown_reason = atom_unchecked("shutdown_reason");
+        let reason = other_arc_process
+            .tuple_from_slice(&[tag, shutdown_reason])
+            .unwrap();
+
+        erlang::exit_1::place_frame_with_arguments(&other_arc_process, Placement::Replace, reason)
+            .unwrap();
+
+        assert!(Scheduler::current().run_through(&other_arc_process));
+
+        assert!(other_arc_process.is_exiting());
+        assert!(!process.is_exiting());
+        assert!(has_no_message(process));
+    });
+}
+
 #[test]
 fn with_true_value_with_linked_receive_exit_message_and_does_not_exit_when_linked_process_exits() {
     with_process(|process| {