Handle all the cases of extract-n-th-argument in the new way, removing the old function.

This makes error messages clearer.

Author: hlisdero

src/translator/sync/condvar_manager.rs

@@ -12,7 +12,7 @@ use crate::data_structures::petri_net_interface::{PetriNet, TransitionRef};
 use crate::naming::condvar::wait_transition_labels;
 use crate::translator::function_call::FunctionPlaces;
 use crate::translator::mir_function::Memory;
-use crate::utils::extract_nth_argument;
+use crate::utils::extract_nth_argument_as_place;
 use log::debug;
 
 #[derive(Default)]
@@ -76,13 +76,15 @@ impl CondvarManager {
         memory: &mut Memory<'tcx>,
     ) {
         // Retrieve the lock guard from the local variable passed to the function as an argument.
-        let lock_guard = extract_nth_argument(args, 1);
+        let lock_guard = extract_nth_argument_as_place(args, 1)
+            .expect("BUG: `std::sync::Condvar::wait` should receive the first argument as a place");
         let mutex_ref = memory.get_linked_lock_guard(&lock_guard);
         // Unlock the mutex when waiting, lock it when the waiting ends.
         mutex_manager.add_unlock_guard(*mutex_ref, &wait_transitions.0, net);
         mutex_manager.add_lock_guard(*mutex_ref, &wait_transitions.1, net);
         // Retrieve the condvar from the local variable passed to the function as an argument.
-        let self_ref = extract_nth_argument(args, 0);
+        let self_ref = extract_nth_argument_as_place(args, 0)
+            .expect("BUG: `std::sync::Condvar::wait` should receive the self reference as a place");
         let condvar_ref = memory.get_linked_condvar(&self_ref);
         self.link_to_wait_call(*condvar_ref, wait_transitions, net);
         // The return value contains the lock guard passed to the function. Link the local variable to it.
@@ -101,7 +103,9 @@ impl CondvarManager {
         memory: &mut Memory<'tcx>,
     ) {
         // Retrieve the condvar from the local variable passed to the function as an argument.
-        let self_ref = extract_nth_argument(args, 0);
+        let self_ref = extract_nth_argument_as_place(args, 0).expect(
+            "BUG: `std::sync::Condvar::notify_one` should receive the self reference as a place",
+        );
         let condvar_ref = memory.get_linked_condvar(&self_ref);
         self.link_to_notify_one_call(*condvar_ref, notify_one_transition, net);
     }

src/translator/sync/mutex_manager.rs

@@ -6,7 +6,7 @@
 use super::mutex::Mutex;
 use crate::data_structures::petri_net_interface::{PetriNet, TransitionRef};
 use crate::translator::mir_function::Memory;
-use crate::utils::extract_nth_argument;
+use crate::utils::extract_nth_argument_as_place;
 use log::debug;
 
 #[derive(Default)]
@@ -53,7 +53,9 @@ impl MutexManager {
         memory: &mut Memory<'tcx>,
     ) {
         // Retrieve the mutex from the local variable passed to the function as an argument.
-        let self_ref = extract_nth_argument(args, 0);
+        let self_ref = extract_nth_argument_as_place(args, 0).expect(
+            "BUG: `std::sync::Mutex::<T>::lock` should receive the self reference as a place",
+        );
         let mutex_ref = memory.get_linked_mutex(&self_ref);
         self.add_lock_guard(*mutex_ref, transition_function_call, net);
         // The return value contains a new lock guard. Link the local variable to it.

src/translator/sync/thread_manager.rs

@@ -12,7 +12,7 @@ use crate::translator::mir_function::{
     CondvarEntries, JoinHandleEntries, LockGuardEntries, Memory, MutexEntries,
 };
 use crate::utils::{
-    extract_closure, extract_def_id_of_called_function_from_operand, extract_nth_argument,
+    extract_closure, extract_def_id_of_called_function_from_operand, extract_nth_argument_as_place,
 };
 use log::{debug, info};
 use std::collections::VecDeque;
@@ -78,7 +78,9 @@ impl ThreadManager {
         memory: &Memory<'tcx>,
     ) {
         // Retrieve the join handle from the local variable passed to the function as an argument.
-        let self_ref = extract_nth_argument(args, 0);
+        let self_ref = extract_nth_argument_as_place(args, 0).expect(
+            "BUG: `std::thread::JoinHandle::<T>::join` should receive the self reference as a place",
+        );
         let thread_ref = memory.get_linked_join_handle(&self_ref);
         self.set_join_transition(*thread_ref, transition_function_call);
     }

src/utils.rs

@@ -43,32 +43,6 @@ pub fn extract_def_id_of_called_function_from_operand<'tcx>(
     }
 }
 
-/// Extracts the n-th argument from the arguments for the function call.
-/// Returns the place corresponding to that argument.
-///
-/// 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,
-) -> rustc_middle::mir::Place<'tcx> {
-    let operand = args
-        .get(index)
-        .expect("BUG: Function should receive at least `index` arguments");
-
-    match operand {
-        rustc_middle::mir::Operand::Move(place) | rustc_middle::mir::Operand::Copy(place) => *place,
-        rustc_middle::mir::Operand::Constant(_) => {
-            panic!("BUG: Function should not receive arguments passed as constants");
-        }
-    }
-}
-
 /// Extracts the n-th argument from the arguments for the function call.
 /// Returns the place corresponding to that argument.
 ///