1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::mem;

/**
 * Leak a piece of data by never calling its destructor
 *
 * Useful for things that are going to be used for the life of the program, but aren't technically
 * static (because they are created in response to arguments, environment, or other
 * configuration/data read at program start).
 *
 * This is a modified version of the proposed rfc: https://github.com/rust-lang/rfcs/pull/1233
 *
 *
 * Notable changes:
 *  - for user convenience, leak() is a non-static method
 *  - Return `&T` instead of `&mut T`
 *
 * While it would be ideal to return a `&'a mut T`, we apparently can't do that due to limitations
 * in rust's borrow checker causing soundness issues. Details are in the RFC liked above.
 */
pub trait Leak<T : ?Sized> {
    fn leak<'a>(self) -> &'a T where T: 'a;
}

impl<T : ?Sized> Leak<T> for Box<T> {
    fn leak<'a>(self) -> &'a T where T: 'a {
        let r = Self::into_raw(self);
        unsafe { &mut *r }
    }
}

/*
 * while String and Vec<T> could have impls in terms of Box, we specialize them because their
 * conversions to Box (into_boxed_slice and into_boxed_str) result in resizing underlying storage
 */

impl Leak<str> for String {
    fn leak<'a>(mut self) -> &'a str where Self: 'a {
        let r: *mut str = &mut self[..];
        mem::forget(self);
        unsafe { &mut *r }
    }
}

impl<T> Leak<[T]> for Vec<T> {
    fn leak<'a>(mut self) -> &'a [T] where [T]: 'a {
        let r: *mut [T] = &mut self[..];
        mem::forget(self);
        unsafe { &mut *r }
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn leak_str() {
        use super::Leak;
        use std::borrow::ToOwned;

        let v = "hi";
        let leaked : &str = {
            let o = v.to_owned();
            o.leak()
        };
        assert_eq!(leaked, v);

        let leaked : &'static str = {
            let o = v.to_owned();
            o.leak()
        };
        assert_eq!(leaked, v);
    }

    #[test]
    fn leak_empty_str() {
        use super::Leak;
        use std::borrow::ToOwned;

        let v = "";
        let leaked : &'static str = {
            let o = v.to_owned();
            o.leak()
        };
        assert_eq!(leaked, v);
    }

    #[test]
    fn leak_vec() {
        use super::Leak;

        let v = vec![3, 5];
        let leaked : &'static [u8] = {
            let o = v.clone();
            o.leak()
        };
        assert_eq!(leaked, &*v);
    }

    #[test]
    fn leak_empty_vec() {
        use super::Leak;

        let v = vec![];
        let leaked : &'static [u8] = {
            let o = v.clone();
            o.leak()
        };
        assert_eq!(leaked, &*v);
    }

    #[test]
    fn leak_box() {
        use super::Leak;

        let v : Box<[&str]> = vec!["hi", "there"].into_boxed_slice();
        let leaked : &'static [&str] = {
            let o = v.clone();
            o.leak()
        };
        assert_eq!(leaked, &*v);
    }

    #[test]
    fn leak_nested() {
        use super::Leak;

        let v : Box<Vec<&str>> = Box::new(vec!["hi", "there"]);
        let leaked : &'static [&str] = {
            let o = v.clone();
            o.leak()
        };
        assert_eq!(leaked, &**v);
    }
}