File: unsafe-fields.rs

package info (click to toggle)
rustc 1.85.0%2Bdfsg3-1
  • links: PTS, VCS
  • area: main
  • in suites: experimental, sid, trixie
  • size: 893,396 kB
  • sloc: xml: 158,127; python: 35,830; javascript: 19,497; cpp: 19,002; sh: 17,245; ansic: 13,127; asm: 4,376; makefile: 1,051; perl: 29; lisp: 29; ruby: 19; sql: 11
file content (109 lines) | stat: -rw-r--r-- 2,257 bytes parent folder | download | duplicates (3)
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
//@ compile-flags: --crate-type=lib
#![allow(incomplete_features)]
#![feature(unsafe_fields)]

struct WithUnsafeField {
    unsafe unsafe_field: u32,
    safe_field: u32,
}

enum A {
    WithUnsafeField { unsafe unsafe_field: u32, safe_field: u32 },
}

fn f(a: A) {
    let A::WithUnsafeField { unsafe_field, safe_field } = a;
    //~^ ERROR
}

struct WithInvalidUnsafeField {
    unsafe unsafe_noncopy_field: Vec<u32>, //~ ERROR
}

struct WithManuallyDropUnsafeField {
    unsafe unsafe_noncopy_field: std::mem::ManuallyDrop<Vec<u32>>,
}

union WithUnsafeFieldUnion {
    unsafe unsafe_field: u32,
    safe_field: u32,
}

impl WithUnsafeField {
    fn new() -> WithUnsafeField {
        unsafe {
            WithUnsafeField {
                unsafe_field: 0,
                safe_field: 0,
            }
        }
    }

    fn new_without_unsafe() -> WithUnsafeField {
        WithUnsafeField { //~ ERROR
            unsafe_field: 0,
            safe_field: 0,
        }
    }

    fn operate_on_safe_field(&mut self) {
        self.safe_field = 2;
        &self.safe_field;
        self.safe_field;
    }

    fn set_unsafe_field(&mut self) {
        unsafe {
            self.unsafe_field = 2;
        }
    }

    fn read_unsafe_field(&self) -> u32 {
        unsafe {
            self.unsafe_field
        }
    }

    fn ref_unsafe_field(&self) -> &u32 {
        unsafe {
            &self.unsafe_field
        }
    }

    fn destructure(&self) {
        unsafe {
            let Self { safe_field, unsafe_field } = self;
        }
    }

    fn set_unsafe_field_without_unsafe(&mut self) {
        self.unsafe_field = 2;
        //~^ ERROR
    }

    fn read_unsafe_field_without_unsafe(&self) -> u32 {
        self.unsafe_field
        //~^ ERROR
    }

    fn ref_unsafe_field_without_unsafe(&self) -> &u32 {
        &self.unsafe_field
        //~^ ERROR
    }

    fn destructure_without_unsafe(&self) {
        let Self { safe_field, unsafe_field } = self;
        //~^ ERROR

        let WithUnsafeField { safe_field, .. } = self;
    }

    fn offset_of(&self) -> usize {
        std::mem::offset_of!(WithUnsafeField, unsafe_field)
    }

    fn raw_const(&self) -> *const u32 {
        &raw const self.unsafe_field
        //~^ ERROR
    }
}