Fix regression: Passing a closure with no captures is now a constant with zero size.

This case must be handled separately with a new utility function `extract_closure`.
Keep the original `extract_nth_argument` for all the other cases.

Update the README accordingly. All tests are green again.

Author: hlisdero

README.md

@@ -48,7 +48,7 @@ This proves extremely useful to get feedback on the types, compiler errors, etc.
 
 As time goes on and the compiler internals change, the code will inevitably need changes to work again.
 
-**The current state of the repository compiled without warnings and with all tests passing with** `rustc 1.70.0-nightly (39f2657d1 2023-03-09)`
+**The current state of the repository compiled without warnings and with all tests passing with** `rustc 1.70.0-nightly (4a04d086c 2023-03-18)`
 
 ### Installation
 

src/lib.rs

@@ -20,6 +20,7 @@
 // These crates are only available when using the nightly toolchain.
 // It suffices to declare them once to use their types and methods in the whole crate.
 extern crate rustc_ast_pretty;
+extern crate rustc_const_eval;
 extern crate rustc_driver;
 extern crate rustc_error_codes;
 extern crate rustc_errors;

src/translator/sync/thread_manager.rs

@@ -11,7 +11,9 @@ use crate::data_structures::petri_net_interface::TransitionRef;
 use crate::translator::mir_function::{
     CondvarEntries, JoinHandleEntries, LockGuardEntries, Memory, MutexEntries,
 };
-use crate::utils::{extract_def_id_of_called_function_from_operand, extract_nth_argument};
+use crate::utils::{
+    extract_closure, extract_def_id_of_called_function_from_operand, extract_nth_argument,
+};
 use log::{debug, info};
 use std::collections::VecDeque;
 
@@ -52,16 +54,13 @@ impl ThreadManager {
             tcx,
         );
 
-        let closure_for_spawn = extract_nth_argument(args, 0);
-        let mutexes = memory.find_mutexes_linked_to_place(closure_for_spawn);
-        let lock_guards = memory.find_lock_guards_linked_to_place(closure_for_spawn);
-        let join_handles = memory.find_join_handles_linked_to_place(closure_for_spawn);
-        let condvars = memory.find_condvars_linked_to_place(closure_for_spawn);
+        let closure_for_spawn = extract_closure(args);
+        let memory_entries = Self::find_sync_variables(closure_for_spawn, memory);
 
         let thread_ref = self.add_thread(
             transition_function_call,
             thread_function_def_id,
-            (mutexes, lock_guards, join_handles, condvars),
+            memory_entries,
         );
         // The return value contains a new join handle. Link the local variable to it.
         memory.link_place_to_join_handle(return_value, thread_ref);
@@ -128,4 +127,36 @@ impl ThreadManager {
     pub fn pop_thread(&mut self) -> Option<Thread> {
         self.threads.pop_front()
     }
+
+    /// Finds sync variables captured by the closure for a new thread.
+    /// Returns the memory entries for each sync variable type that should be re-mapped in the new thread's memory.
+    ///
+    /// If the closure is `None` (no variables were captured, it is a `ZeroSizedType`),
+    /// then return empty vectors for the memory entries.
+    fn find_sync_variables<'tcx>(
+        closure: Option<rustc_middle::mir::Place<'tcx>>,
+        memory: &mut Memory<'tcx>,
+    ) -> (
+        MutexEntries,
+        LockGuardEntries,
+        JoinHandleEntries,
+        CondvarEntries,
+    ) {
+        closure.map_or_else(
+            || {
+                let mutexes = vec![];
+                let lock_guards = vec![];
+                let join_handles = vec![];
+                let condvars = vec![];
+                (mutexes, lock_guards, join_handles, condvars)
+            },
+            |place| {
+                let mutexes = memory.find_mutexes_linked_to_place(place);
+                let lock_guards = memory.find_lock_guards_linked_to_place(place);
+                let join_handles = memory.find_join_handles_linked_to_place(place);
+                let condvars = memory.find_condvars_linked_to_place(place);
+                (mutexes, lock_guards, join_handles, condvars)
+            },
+        )
+    }
 }

src/utils.rs

@@ -49,6 +49,10 @@ pub fn extract_def_id_of_called_function_from_operand<'tcx>(
 /// This is also useful for obtaining the self reference for method calls.
 /// For example: The call `mutex.lock()` desugars to `std::sync::Mutex::lock(&mutex)`
 /// where `&self` is the first argument.
+///
+/// # Panics
+///
+/// If the argument passed to the function is a constant, then the function panics.
 pub fn extract_nth_argument<'tcx>(
     args: &[rustc_middle::mir::Operand<'tcx>],
     index: usize,
@@ -60,9 +64,50 @@ pub fn extract_nth_argument<'tcx>(
     match operand {
         rustc_middle::mir::Operand::Move(place) | rustc_middle::mir::Operand::Copy(place) => *place,
         rustc_middle::mir::Operand::Constant(_) => {
-            unimplemented!(
-                "Passing an operand of type Operand::Constant to a function is not implemented yet"
-            );
+            panic!("BUG: Function should not receive arguments passed as constants");
+        }
+    }
+}
+
+/// Extracts the closure passed as the 0-th argument to `std::thread::spawn`.
+/// Returns the place corresponding to that argument.
+///
+/// If a valid place cannot be found, then the operand was passed as a constant.
+/// If it is a `rustc_middle::mir::interpret::value::ConstValue::ZeroSized` return `None`.
+///
+/// # Panics
+///
+/// If the operand was passed a constant with user-defined type,
+/// a type constant (i.e. `T`) or an unevaluated constant, then the functions panics.
+pub fn extract_closure<'tcx>(
+    args: &[rustc_middle::mir::Operand<'tcx>],
+) -> Option<rustc_middle::mir::Place<'tcx>> {
+    let operand = args
+        .get(0)
+        .expect("BUG: `std::thread::spawn` should receive at least one argument");
+
+    match operand {
+        rustc_middle::mir::Operand::Move(place) | rustc_middle::mir::Operand::Copy(place) => {
+            Some(*place)
+        }
+        rustc_middle::mir::Operand::Constant(boxed_const) => {
+            let unboxed_const = **boxed_const;
+            assert!(unboxed_const.user_ty.is_none(), "BUG: The closure passed to `std::thread::spawn` should not be of type `Operand::Constant` with user-defined type");
+            let constant_kind = unboxed_const.literal;
+            match constant_kind {
+                rustc_middle::mir::ConstantKind::Ty(_) => {
+                    panic!("BUG: The closure passed to `std::thread::spawn` should not be a constant containing a type");
+                }
+                rustc_middle::mir::ConstantKind::Unevaluated(_, _) => {
+                    panic!("BUG: The closure passed to `std::thread::spawn` should not be a unevaluated constant");
+                }
+                rustc_middle::mir::ConstantKind::Val(value, _ty) => {
+                    if value == rustc_const_eval::interpret::ConstValue::ZeroSized {
+                        return None;
+                    }
+                    panic!("BUG: The closure passed to `std::thread::spawn` should not be a constant whose value is not a zero-sized type");
+                }
+            }
         }
     }
 }