WIP: Handle MIR aggregate assignments in an attempt to fix the problems introduced by the new nightly compiler.

Related issue:
rust-lang/rust#107678
The commit that caused the issue:
rust-lang/rust@9dee4e4

Author: hlisdero

src/translator.rs

@@ -38,8 +38,8 @@ use netcrab::petri_net::{PetriNet, PlaceRef};
 use rustc_middle::mir::visit::Visitor;
 use special_function::{call_diverging_function, call_panic_function, is_panic_function};
 use sync::{
-    handle_ref_assignment, handle_use_copy_assignment, handle_use_move_assignment, ArcManager,
-    CondvarManager, MutexManager, ThreadManager,
+    handle_aggregate_assignment, handle_ref_assignment, handle_use_copy_assignment,
+    handle_use_move_assignment, ArcManager, CondvarManager, MutexManager, ThreadManager,
 };
 
 pub struct Translator<'tcx> {
@@ -270,4 +270,22 @@ impl<'tcx> Translator<'tcx> {
         let function = self.call_stack.peek_mut();
         handle_ref_assignment(place, rhs, &mut function.memory, function.def_id, self.tcx);
     }
+
+    /// Handles MIR assignments of the form: `_X = { copy_data: move _Y }`.
+    /// This is the handler for the enum variant `rustc_middle::mir::Rvalue::Aggregate` in the MIR Visitor.
+    /// <https://doc.rust-lang.org/stable/nightly-rustc/rustc_middle/mir/enum.Rvalue.html#variant.Aggregate>
+    fn handle_aggregate_assignment(
+        &mut self,
+        place: &rustc_middle::mir::Place<'tcx>,
+        operands: &Vec<rustc_middle::mir::Operand<'tcx>>,
+    ) {
+        let function = self.call_stack.peek_mut();
+        handle_aggregate_assignment(
+            place,
+            operands,
+            &mut function.memory,
+            function.def_id,
+            self.tcx,
+        );
+    }
 }

src/translator/mir_visitor.rs

@@ -40,6 +40,9 @@ impl<'tcx> Visitor<'tcx> for Translator<'tcx> {
             rustc_middle::mir::Rvalue::Ref(_, _, rhs) => {
                 self.handle_ref_assignment(place, rhs);
             }
+            rustc_middle::mir::Rvalue::Aggregate(_, operands) => {
+                self.handle_aggregate_assignment(place, operands);
+            }
             // No need to do anything for the other cases for now.
             _ => {}
         }

src/translator/sync.rs

@@ -124,3 +124,56 @@ pub fn handle_ref_assignment<'tcx>(
         memory.link_place_to_same_condvar(*place, *rhs);
     }
 }
+
+/// Handles MIR assignments of the form: `_X = { copy_data: move _Y }`.
+/// If the right-hand side contains a synchronization variable, link it to the left-hand side.
+pub fn handle_aggregate_assignment<'tcx>(
+    place: &rustc_middle::mir::Place<'tcx>,
+    operands: &Vec<rustc_middle::mir::Operand<'tcx>>,
+    memory: &mut Memory<'tcx>,
+    caller_function_def_id: rustc_hir::def_id::DefId,
+    tcx: rustc_middle::ty::TyCtxt<'tcx>,
+) {
+    for operand in operands {
+        // Extract the place to be assignment
+        let rhs = match operand {
+            rustc_middle::mir::Operand::Copy(place) | rustc_middle::mir::Operand::Move(place) => {
+                place
+            }
+            // Nothing to do if we found a constant as one of the operands.
+            rustc_middle::mir::Operand::Constant(_) => continue,
+        };
+
+        if is_place_with_concrete_type(rhs, "std::sync::Mutex<T>", caller_function_def_id, tcx)
+            || is_place_with_concrete_type(
+                rhs,
+                "std::sync::Arc<std::sync::Mutex<T>>",
+                caller_function_def_id,
+                tcx,
+            )
+        {
+            memory.link_place_to_same_mutex(*place, *rhs);
+        } else if is_place_with_concrete_type(
+            rhs,
+            "std::sync::MutexGuard<'a, T>",
+            caller_function_def_id,
+            tcx,
+        ) {
+            memory.link_place_to_same_lock_guard(*place, *rhs);
+        } else if is_place_with_concrete_type(
+            rhs,
+            "std::thread::JoinHandle<T>",
+            caller_function_def_id,
+            tcx,
+        ) {
+            memory.link_place_to_same_join_handle(*place, *rhs);
+        } else if is_place_with_concrete_type(
+            rhs,
+            "std::sync::Condvar",
+            caller_function_def_id,
+            tcx,
+        ) {
+            memory.link_place_to_same_condvar(*place, *rhs);
+        }
+    }
+}