I learned (maybe) bit about lifetimes of course with help of others and my own
Is this right model to have
Consider this function
fn aaa<'a, 'b>(arg: &'a mut [u8;2]) -> (&'a mut [u8], &'a mut [u8]) {
let a = unsafe {arg.split_at_mut_unchecked(1)};
(a.0, unsafe {core::slice::from_raw_parts_mut(a.1 as *mut [u8] as *mut u8 as usize as *mut u8, 1)})
}
This function has unbounded lifetime so applying with both parameters ‘a
fn main() {
let mut a = [6u8; 2];
let (b, c) = aaa(&mut a);
c[0] = 9;
drop(a);
let d = c;
}
let mut a = [6u8; 2]; // type has ‘a
let (b, c) = aaa(&mut a); // b and c has type &’a _;
drop(a)
// due to type a, is an array it is move semantics
// Invalidates all type &’a _;
// You are allowed to move types as long it doesn’t conflict
// with using the invalidated references afterwards
// But we are so
let d = c;
// due to Non-lexical lifetimes
// so we are “extending” the lifetime
Conflicts error appear but if we change the function signature
fn aaa<'a, 'b>(arg: &'a mut [u8;2]) -> (&'a mut [u8], &'a mut [u8])
// to
fn aaa<'a, 'b>(arg: &'a mut [u8;2]) -> (&'a mut [u8], &'b mut [u8])
// notice slight change on return parameters
so
fn main() {
let mut a = [6u8; 2]; // type has ‘a
let (b, c) = aaa(&mut a);
// type b has &’a _ while c has &’b _
// Unbounded lifetime!
c[0] = 9;
drop(a);
// Invalidates all &’a _
let d = c;
// c is &’b _ so not invalidated
// Undefined behaviour through use after free
}
Here another example
struct A<'a> {
a: &'a str,
}
impl A<'_> {
fn a<'a, 'b, 'c>(arg: &'a mut A<'b>) -> &'b mut A<'c> {
unsafe {&mut *(arg as *mut _ as usize as *mut _)}
}
fn b<'a, 'b>(arg: &'a mut A<'b>) -> &'a mut A<'b> {
arg
}
}
With associated function “a” being unsound and possible ub
While associated function “b” being safe
Applying it here
fn main() {
let a = String::new(); // has ‘a
let mut aaaaa = A {a: &a}; // contains &’a _
// But now SHOULD have has ‘b but doesn’t
let c = A::a(&mut aaaaa);
// c is SHOULD be type &’b mut _ BUT is not
// c has &’a mut A<‘c> ‘c is unbounded
drop(aaaaa);
// Invalidates &’b _ but there is none
c.a = "aaaaa"
// Another use after free
}
But what interesting is that changing
drop(aaaaa);
// to
drop(a);
It errors as
drop(a)
// Invalidates &’a _
let c = A::a(&mut aaaaa)
// c has type &’a mut A<‘c>
// while the argument has &’b mut A<‘a>
// due to the function signature
Note that:
// Also lifetime annotations differ from the “lifetimes labels” applied by compiler
// e.g
fn a<‘a>(a: &’a u8) -> &’a u8 {
a
}
fn main() {
let local = 5u8;
let one_ref = &local; has type ‘1
let two_ref = &local; has type ‘2
let three_ref = a(two_ref) has type ‘3
}
// &T is copy so copy semantics
// Lifetime annotation differs from actual lifetimes viewed by the compiler
To have even more bad signature such by
changing signature
fn a<'a, 'b, 'c>(arg: &'a mut A<'b>) -> &'b mut A<'c>
// to
fn a<'a, 'b, 'c, 'd>(arg: &'a mut A<'b>) -> &'d mut A<'c>
Both of them are unbounded so dropping either of them will compile
(no good as use after free)
Of course
struct Newtype(u8);
fn main() {
let mut a = Newtype(5u8);
let refe = &mut a;
let I_know_a_guy_whos_know_a_guy = &refe;
drop(a);
// Invalidates &’a _
}
Now this model would dangle the “I_know_a_guy_whos_know_a_guy”
But I am assuming there is the implicit bound of ‘b: ‘a
So its invalidating ‘b as well to prevent dangling references
Bounds, now I understand little bit as such there are other cases of compiler extending lifetimes. I heard it here,
Here this example
struct A<'a> {
a: &'a str,
}
struct Phantom<'a> {
a: core::marker::PhantomData<&'a mut ()>,
}
impl A<'_> {
fn b<'a, 'b, 'c>(arg: &'a mut A<'b>) -> (&'a mut A<'b>, Phantom<'c>)
where
'a: 'c,
{
(
arg,
Phantom {
a: core::marker::PhantomData,
},
)
}
}
fn main() {
let a = String::new();
let mut aaaaa = A { a: &a };
{
let (mut c, mut phantom) = A::b(&mut aaaaa);
aaaaa.a = "aaaaa";
let c = phantom;
}
}
This errors due to the bound of ‘a: ‘c, it can be fixed by commenting on the bound, or commenting on “let c = phantom” (due to non-lexical lifetime) but it can also error if the bound is there (but not “let c = phantom”)
Using
impl Drop for Phantom<'a> {
fn drop(&mut self) {/*...*/}
}
The type will then be dropped at end of scope or a function consuming the type rather than “borrowing” it.
Now I get little of for<‘a> but not alot,
Of course I heard closures are “opaque” syntactic sugar so for<‘a> is used like fn a<‘a>(blah blah blah) -> blah but applied to for<‘a> | blah | { blah }
Can anybody give feedback please (if your wondering what point of this post) and how improve this model of understanding lifetimes or is it good enough