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
134
135
136
137
138
139
140
|
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Verifies all possible restrictions for statics values.
use std::marker;
struct WithDtor;
impl Drop for WithDtor {
fn drop(&mut self) {}
}
// This enum will be used to test the following rules:
// 1. Variants are safe for static
// 2. Expr calls are allowed as long as they arguments are safe
// 3. Expr calls with unsafe arguments for statics are rejected
enum SafeEnum {
Variant1,
Variant2(int),
Variant3(WithDtor),
Variant4(String)
}
// These should be ok
static STATIC1: SafeEnum = SafeEnum::Variant1;
static STATIC2: SafeEnum = SafeEnum::Variant2(0);
// This one should fail
static STATIC3: SafeEnum = SafeEnum::Variant3(WithDtor);
//~^ ERROR statics are not allowed to have destructors
// This enum will be used to test that variants
// are considered unsafe if their enum type implements
// a destructor.
enum UnsafeEnum {
Variant5,
Variant6(int)
}
impl Drop for UnsafeEnum {
fn drop(&mut self) {}
}
static STATIC4: UnsafeEnum = UnsafeEnum::Variant5;
//~^ ERROR statics are not allowed to have destructors
static STATIC5: UnsafeEnum = UnsafeEnum::Variant6(0);
//~^ ERROR statics are not allowed to have destructors
struct SafeStruct {
field1: SafeEnum,
field2: SafeEnum,
}
// Struct fields are safe, hence this static should be safe
static STATIC6: SafeStruct = SafeStruct{field1: SafeEnum::Variant1, field2: SafeEnum::Variant2(0)};
// field2 has an unsafe value, hence this should fail
static STATIC7: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
field2: SafeEnum::Variant3(WithDtor)};
//~^ ERROR statics are not allowed to have destructors
// Test variadic constructor for structs. The base struct should be examined
// as well as every field present in the constructor.
// This example shouldn't fail because all the fields are safe.
static STATIC8: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
..SafeStruct{field1: SafeEnum::Variant1,
field2: SafeEnum::Variant1}};
// This example should fail because field1 in the base struct is not safe
static STATIC9: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
..SafeStruct{field1: SafeEnum::Variant3(WithDtor),
field2: SafeEnum::Variant1}};
//~^^ ERROR statics are not allowed to have destructors
struct UnsafeStruct;
impl Drop for UnsafeStruct {
fn drop(&mut self) {}
}
// Types with destructors are not allowed for statics
static STATIC10: UnsafeStruct = UnsafeStruct;
//~^ ERROR statics are not allowed to have destructor
struct MyOwned;
static STATIC11: Box<MyOwned> = box MyOwned;
//~^ ERROR statics are not allowed to have custom pointers
// The following examples test that mutable structs are just forbidden
// to have types with destructors
// These should fail
static mut STATIC12: UnsafeStruct = UnsafeStruct;
//~^ ERROR mutable statics are not allowed to have destructors
//~^^ ERROR statics are not allowed to have destructors
static mut STATIC13: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
//~^ ERROR mutable statics are not allowed to have destructors
field2: SafeEnum::Variant3(WithDtor)};
//~^ ERROR: statics are not allowed to have destructors
static mut STATIC14: SafeStruct = SafeStruct {
//~^ ERROR mutable statics are not allowed to have destructors
field1: SafeEnum::Variant1,
field2: SafeEnum::Variant4("str".to_string())
};
static STATIC15: &'static [Box<MyOwned>] = &[
box MyOwned, //~ ERROR statics are not allowed to have custom pointers
box MyOwned, //~ ERROR statics are not allowed to have custom pointers
];
static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = (
&box MyOwned, //~ ERROR statics are not allowed to have custom pointers
&box MyOwned, //~ ERROR statics are not allowed to have custom pointers
);
static mut STATIC17: SafeEnum = SafeEnum::Variant1;
//~^ ERROR mutable statics are not allowed to have destructors
static STATIC19: Box<int> =
box 3;
//~^ ERROR statics are not allowed to have custom pointers
pub fn main() {
let y = { static x: Box<int> = box 3; x };
//~^ ERROR statics are not allowed to have custom pointers
}
|
