hmmm broken

Author: azaleacolburn

Diff for: src/adjuster.rs

@@ -94,29 +94,67 @@ fn line_rearrangement_mut_const_overlap(
     let mut mut_ptr_usages = mut_ptr.usages.iter();
     let mut const_ptr_usages = const_ptr.usages.iter();
 
-    let first_mut_ptr_usage_in_reference = mut_ptr_usages
-        .find(|mut_usage| {
-            const_reference
-                .borrow()
-                .contained_within_current_range(mut_usage.get_line_number())
-        })
-        .unwrap();
+    let const_range = const_reference.borrow().get_range();
+    let mut_range = mut_reference.borrow().get_range();
 
-    let last_const_usage_in_reference = const_ptr_usages
-        .find(|const_usage| {
-            mut_reference
-                .borrow()
-                .contained_within_current_range(const_usage.get_line_number())
-        })
-        .unwrap();
+    match const_range.start > mut_range.start {
+        true => {
+            let first_mut_usage_in_reference = mut_ptr_usages
+                .find(|mut_usage| {
+                    const_reference
+                        .borrow()
+                        .contained_within_current_range(mut_usage.get_line_number())
+                })
+                .unwrap();
 
-    if first_mut_ptr_usage_in_reference.get_line_number()
-        > last_const_usage_in_reference.get_line_number()
-    {
-        // rearrange_lines(first_line, second_line, root);
-        true
-    } else {
-        false
+            let last_const_usage_in_reference = const_ptr_usages
+                .filter(|const_usage| {
+                    mut_reference
+                        .borrow()
+                        .contained_within_current_range(const_usage.get_line_number())
+                })
+                .last()
+                .unwrap();
+
+            // if first_mut_usage_in_reference.get_line_number()
+            //     > last_const_usage_in_reference.get_line_number()
+            // {
+            //     // TODO Iteratively move all overlapped lines
+            //     rearrange_lines(mut_range.start, const_range.end, root);
+            //     true
+            // } else {
+            //     false
+            // }
+            false
+        }
+        false => {
+            let last_mut_usage_in_reference = mut_ptr_usages
+                .filter(|mut_usage| {
+                    mut_reference
+                        .borrow()
+                        .contained_within_current_range(mut_usage.get_line_number())
+                })
+                .last()
+                .unwrap();
+
+            let first_const_usage_in_reference = const_ptr_usages
+                .find(|const_usage| {
+                    mut_reference
+                        .borrow()
+                        .contained_within_current_range(const_usage.get_line_number())
+                })
+                .unwrap();
+
+            if first_const_usage_in_reference.get_line_number()
+                > last_mut_usage_in_reference.get_line_number()
+            {
+                // TODO Iteratively move all overlapped lines
+                rearrange_lines(mut_range.start, const_range.end, root);
+                true
+            } else {
+                false
+            }
+        }
     }
 }
 

Diff for: src/test.rs

@@ -29,34 +29,24 @@ fn three_mut_layered() {
     );
 }
 
-/// Invalid rust code if directly translated
-/// Should be caught by the checker and a safe solution should be applied
-/// We can only ever use `*t.borrow()` or `*t.borrow_mut()` when using t
-/// Because it has to act exactly like the value t would in C.
-/// eg.
 /// ```rust
 /// fn main() -> () {
-///     let t: Rc<RefCell<i32>> = Rc::new(RefCell::new(0));
-///     let g: Rc<RefCell<i32>> = t.clone();
-///     *t.borrow_mut() = 1;
-///     *g.borrow_mut() = 2;
-///     // When function calls come about
-///     f(*t.borrow())
-///     f(g)
-///     f(g, t.borrow_mut()) // this is fine
-///     f(*g.borrow(), *t.borrow_mut) // this is not ok
+///     let t = 0;
+///     t = 1;
+///     let g = &mut t;
+///     *g = 2;
 /// }
 /// ```
 #[test]
-fn value_overlap() {
+fn value_mut_ptr_overlap() {
     validate(
         "int main() {
             int t = 0;
             int* g = &t;
             t = 1;
             *g = 2;
         }",
-        "value_overlap",
+        "value_mut_ptr_overlap",
     );
 }
 
@@ -102,6 +92,31 @@ fn value_const_ptr_overlap() {
 //         "deref_value_assignment",
 //     );
 // }
+//
+
+/// ```rust
+/// fn main() {
+///     let n = 0;
+///     let g = &n;
+///     let t = *g;
+///     let m = &mut n;
+///     *m = 4;
+/// }
+#[test]
+fn const_mut_ptr_overlap() {
+    validate(
+        "int main() {
+            int n = 0;
+            int* g = &n;
+            int* m = &n;
+            *m = 9;
+            int t = *g;
+            g;
+            *m = 4;
+        }",
+        "const_mut_ptr_overlap",
+    );
+}
 
 /// ```rust
 /// fn main() {

Diff for: translated/const_mut_ptr_overlap_test.rs

@@ -0,0 +1,8 @@
+use std::{cell::RefCell, rc::Rc};
+fn main() -> () {
+	let n: Rc<RefCell<i32>> = Rc::new(RefCell::new(0));
+	let g: Rc<RefCell<i32>> = n.clone();
+	let m: Rc<RefCell<i32>> = n.clone();
+	let _t: i32 = *g.borrow();
+	*m.borrow_mut() = 4;
+}

Diff for: translated/value_mut_ptr_overlap_test.rs

@@ -0,0 +1,6 @@
+fn main() -> () {
+	let mut t: i32 = 0;
+	t = 1;
+	let mut g: &mut i32  = &mut t;
+	*g = 2;
+}