}
}
// If we got here, we did not find our item. We have to error to satisfy U3.
- Err(format!("Borrow being dereferenced ({:?}) does not exist on the stack", bor))
+ Err(format!("Borrow being dereferenced ({:?}) does not exist on the borrow stack", bor))
}
/// Perform an actual memory access using `bor`. We do not know any types here
}
// If we got here, we did not find our item.
err!(MachineError(format!(
- "Borrow being accessed ({:?}) does not exist on the stack",
+ "Borrow being accessed ({:?}) does not exist on the borrow stack",
bor
)))
}
retarget(&mut target_alias, target);
// now `target_alias` points to the same thing as `target`
*target = 13;
- let _val = *target_alias; //~ ERROR does not exist on the stack
+ let _val = *target_alias; //~ ERROR does not exist on the borrow stack
}
use std::mem;
-pub fn safe(_x: &mut i32, _y: &i32) {} //~ ERROR does not exist on the stack
+pub fn safe(_x: &mut i32, _y: &i32) {} //~ ERROR does not exist on the borrow stack
fn main() {
let mut x = 0;
unknown_code_2();
// We know this will return 5
- *our //~ ERROR does not exist on the stack
+ *our //~ ERROR does not exist on the borrow stack
}
// Now comes the evil context
let v1 = safe::as_mut_slice(&v);
let _v2 = safe::as_mut_slice(&v);
v1[1] = 5;
- //~^ ERROR does not exist on the stack
+ //~^ ERROR does not exist on the borrow stack
}
assert!(mid <= len);
(from_raw_parts_mut(ptr, len - mid), // BUG: should be "mid" instead of "len - mid"
- //~^ ERROR does not exist on the stack
+ //~^ ERROR does not exist on the borrow stack
from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
}
}
let xref = unsafe { &mut *xraw }; // derived from raw, so using raw is still okay...
callee(xraw);
let _val = *xref; // ...but any use of raw will invalidate our ref.
- //~^ ERROR: does not exist on the stack
+ //~^ ERROR: does not exist on the borrow stack
}
fn callee(xraw: *mut i32) {
let xref = unsafe { &mut *xraw }; // derived from raw, so using raw is still okay...
callee(xraw);
let _val = *xref; // ...but any use of raw will invalidate our ref.
- //~^ ERROR: does not exist on the stack
+ //~^ ERROR: does not exist on the borrow stack
}
fn callee(xraw: *mut i32) {
let xref2 = &mut *xref1; // derived from xref1, so using raw is still okay...
callee(xref1_sneaky);
let _val = *xref2; // ...but any use of it will invalidate our ref.
- //~^ ERROR: does not exist on the stack
+ //~^ ERROR: does not exist on the borrow stack
}
fn callee(xref1: usize) {
let xraw = xref1 as *mut _;
let xref2 = unsafe { &mut *xraw };
let _val = unsafe { *xraw }; // use the raw again, this invalidates xref2 *even* with the special read except for uniq refs
- let _illegal = *xref2; //~ ERROR does not exist on the stack
+ let _illegal = *xref2; //~ ERROR does not exist on the borrow stack
}
let _val = *xref; // we can even still use our mutable reference
mem::forget(unsafe { ptr::read(xshr) }); // but after reading through the shared ref
let _val = *xref; // the mutable one is dead and gone
- //~^ ERROR does not exist on the stack
+ //~^ ERROR does not exist on the borrow stack
}
let target2 = target as *mut _;
drop(&mut *target); // reborrow
// Now make sure our ref is still the only one.
- unsafe { *target2 = 13; } //~ ERROR does not exist on the stack
+ unsafe { *target2 = 13; } //~ ERROR does not exist on the borrow stack
let _val = *target;
}
// Make sure raw ptr with raw tag cannot mutate frozen location without breaking the shared ref.
let r#ref = ⌖ // freeze
let ptr = r#ref as *const _ as *mut _; // raw ptr, with raw tag
- unsafe { *ptr = 42; } //~ ERROR does not exist on the stack
+ unsafe { *ptr = 42; } //~ ERROR does not exist on the borrow stack
let _val = *r#ref;
}
let xref = unsafe { &mut *xraw }; // derived from raw, so using raw is still okay...
callee(xraw);
let _val = *xref; // ...but any use of raw will invalidate our ref.
- //~^ ERROR: does not exist on the stack
+ //~^ ERROR: does not exist on the borrow stack
}
fn callee(xraw: *mut i32) {
let xref = unsafe { &mut *xraw };
let xref_in_mem = Box::new(xref);
let _val = unsafe { *xraw }; // invalidate xref
- let _val = *xref_in_mem; //~ ERROR does not exist on the stack
+ let _val = *xref_in_mem; //~ ERROR does not exist on the borrow stack
}
let y: *const i32 = &x;
x = 1; // this invalidates y by reactivating the lowermost uniq borrow for this local
- assert_eq!(unsafe { *y }, 1); //~ ERROR does not exist on the stack
+ assert_eq!(unsafe { *y }, 1); //~ ERROR does not exist on the borrow stack
assert_eq!(x, 1);
}
let xraw = x as *mut _;
let xref = unsafe { &mut *xraw };
let _val = unsafe { *xraw }; // invalidate xref
- foo(xref); //~ ERROR does not exist on the stack
+ foo(xref); //~ ERROR does not exist on the borrow stack
}
fn fun2() {
// Now we use a pointer we are not allowed to use
- let _x = unsafe { *PTR }; //~ ERROR does not exist on the stack
+ let _x = unsafe { *PTR }; //~ ERROR does not exist on the borrow stack
}
fn main() {
let xraw = x as *mut (i32, i32);
let ret = unsafe { &mut (*xraw).1 };
let _val = unsafe { *xraw }; // invalidate xref
- ret //~ ERROR does not exist on the stack
+ ret //~ ERROR does not exist on the borrow stack
}
fn main() {
let xraw = x as *mut (i32, i32);
let ret = Some(unsafe { &mut (*xraw).1 });
let _val = unsafe { *xraw }; // invalidate xref
- ret //~ ERROR does not exist on the stack
+ ret //~ ERROR does not exist on the borrow stack
}
fn main() {
let xraw = x as *mut (i32, i32);
let ret = (unsafe { &mut (*xraw).1 },);
let _val = unsafe { *xraw }; // invalidate xref
- ret //~ ERROR does not exist on the stack
+ ret //~ ERROR does not exist on the borrow stack
}
fn main() {
let _raw: *mut i32 = unsafe { mem::transmute(&mut x[0]) };
// `raw` still carries a tag, so we get another pointer to the same location that does not carry a tag
let raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
- unsafe { *raw = 13; } //~ ERROR does not exist on the stack
+ unsafe { *raw = 13; } //~ ERROR does not exist on the borrow stack
}
let mut x = 42;
let raw = &mut x as *mut i32 as usize as *mut i32;
let _ptr = &mut x;
- unsafe { *raw = 13; } //~ ERROR does not exist on the stack
+ unsafe { *raw = 13; } //~ ERROR does not exist on the borrow stack
}
projects / rust.git / commitdiff