.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
lang/
alloc/
ast/
gen/
il/
layout/
lower/
manifest/
module/
parser/
resolver/
tests/
fixtures/
core.rad
161.9 KiB
opacity.rad
14.5 KiB
regions.rad
41.7 KiB
safety.rad
191.8 KiB
structure.rad
188.8 KiB
metadata.rad
2.6 KiB
printer.rad
33.0 KiB
refs.rad
66.5 KiB
tests.rad
23.6 KiB
scanner/
sexpr/
alloc.rad
1.2 KiB
ast.rad
36.0 KiB
gen.rad
513 B
il.rad
48.5 KiB
layout.rad
6.9 KiB
lower.rad
487.6 KiB
manifest.rad
22.5 KiB
module.rad
17.8 KiB
package.rad
1.5 KiB
parser.rad
114.1 KiB
pretty.rad
103.6 KiB
resolver.rad
508.1 KiB
scanner.rad
19.3 KiB
sexpr.rad
7.1 KiB
strings.rad
3.3 KiB
types.rad
620 B
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/lang/resolver/tests/safety.rad
raw
| 1 | //! Resolver tests: typed catch, trait instances, constant expressions, unsafe rules, borrows, and |
| 2 | //! ownership. |
| 3 | |
| 4 | use std::testing; |
| 5 | use std::lang::resolver; |
| 6 | use std::lang::ast; |
| 7 | use std::lang::resolver::tests::*; |
| 8 | |
| 9 | // --- Multi-error typed catch tests --- |
| 10 | |
| 11 | @test unsafe fn testTypedCatchExhaustive() throws (testing::TestError) { |
| 12 | let mut a = testResolver(); |
| 13 | let program = |
| 14 | "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrB { return 1; }; }"; |
| 15 | let result = try resolveProgramStr(&mut a, program); |
| 16 | try expectNoErrors(&result); |
| 17 | } |
| 18 | |
| 19 | @test unsafe fn testTypedCatchNonExhaustive() throws (testing::TestError) { |
| 20 | let mut a = testResolver(); |
| 21 | let program = |
| 22 | "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; }; }"; |
| 23 | let result = try resolveProgramStr(&mut a, program); |
| 24 | try expectErrorKind(&result, resolver::ErrorKind::TryCatchNonExhaustive); |
| 25 | } |
| 26 | |
| 27 | @test unsafe fn testTypedCatchDuplicate() throws (testing::TestError) { |
| 28 | let mut a = testResolver(); |
| 29 | let program = |
| 30 | "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch e as ErrA { return 1; }; }"; |
| 31 | let result = try resolveProgramStr(&mut a, program); |
| 32 | try expectErrorKind(&result, resolver::ErrorKind::TryCatchDuplicateType); |
| 33 | } |
| 34 | |
| 35 | @test unsafe fn testTypedCatchWithCatchAll() throws (testing::TestError) { |
| 36 | let mut a = testResolver(); |
| 37 | let program = |
| 38 | "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrA { return 0; } catch { return 1; }; }"; |
| 39 | let result = try resolveProgramStr(&mut a, program); |
| 40 | try expectNoErrors(&result); |
| 41 | } |
| 42 | |
| 43 | @test unsafe fn testTypedCatchWrongType() throws (testing::TestError) { |
| 44 | let mut a = testResolver(); |
| 45 | let program = |
| 46 | "union ErrA { A } union ErrB { B } union ErrC { C } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e as ErrC { return 0; } catch e as ErrA { return 1; }; }"; |
| 47 | let result = try resolveProgramStr(&mut a, program); |
| 48 | try expectErrorKind(&result, resolver::ErrorKind::TryIncompatibleError); |
| 49 | } |
| 50 | |
| 51 | @test unsafe fn testInferredCatchMultiError() throws (testing::TestError) { |
| 52 | let mut a = testResolver(); |
| 53 | let program = |
| 54 | "union ErrA { A } union ErrB { B } fn f() -> i32 throws (ErrA, ErrB) { throw ErrA::A(); return 0; } fn g() -> i32 { return try f() catch e { return 0; }; }"; |
| 55 | let result = try resolveProgramStr(&mut a, program); |
| 56 | try expectErrorKind(&result, resolver::ErrorKind::TryCatchMultiError); |
| 57 | } |
| 58 | |
| 59 | @test unsafe fn testResolveInstanceMissingMethod() throws (testing::TestError) { |
| 60 | let mut a = testResolver(); |
| 61 | let program = "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R {}"; |
| 62 | let result = try resolveProgramStr(&mut a, program); |
| 63 | try expectErrorKind(&result, resolver::ErrorKind::MissingTraitMethod("f")); |
| 64 | } |
| 65 | |
| 66 | @test unsafe fn testResolveInstanceUnknownMethod() throws (testing::TestError) { |
| 67 | let mut a = testResolver(); |
| 68 | let program = |
| 69 | "trait S { fn (*S) f() -> i32; } record R { x: i32 } instance S for R { fn (self: *R) x() -> i32 { return 0; } }"; |
| 70 | let result = try resolveProgramStr(&mut a, program); |
| 71 | try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("x")); |
| 72 | } |
| 73 | |
| 74 | @test unsafe fn testResolveTraitDuplicateMethodRejected() throws (testing::TestError) { |
| 75 | let mut a = testResolver(); |
| 76 | let program = |
| 77 | "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }"; |
| 78 | let result = try resolveProgramStr(&mut a, program); |
| 79 | try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("add")); |
| 80 | } |
| 81 | |
| 82 | @test unsafe fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) { |
| 83 | let mut a = testResolver(); |
| 84 | let program = |
| 85 | "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }"; |
| 86 | let result = try resolveProgramStr(&mut a, program); |
| 87 | let err = try expectError(&result); |
| 88 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 89 | } |
| 90 | |
| 91 | @test unsafe fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) { |
| 92 | let mut a = testResolver(); |
| 93 | let program = |
| 94 | "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }"; |
| 95 | let result = try resolveProgramStr(&mut a, program); |
| 96 | try expectErrorKind(&result, resolver::ErrorKind::MissingTry); |
| 97 | } |
| 98 | |
| 99 | /// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type). |
| 100 | /// The instance method could mutate through what was originally an immutable pointer. |
| 101 | @test unsafe fn testResolveInstanceMutReceiverOnImmutableTrait() throws (testing::TestError) { |
| 102 | let mut a = testResolver(); |
| 103 | let program = |
| 104 | "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { set c.value = c.value + 1; return c.value; } }"; |
| 105 | let result = try resolveProgramStr(&mut a, program); |
| 106 | // Should reject: instance declares *mut receiver but trait only requires immutable. |
| 107 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverMutabilityMismatch); |
| 108 | } |
| 109 | |
| 110 | /// Instance method declares different parameter types than the trait. |
| 111 | /// The resolver should reject the mismatch rather than silently using the trait's types. |
| 112 | @test unsafe fn testResolveInstanceParamTypeMismatch() throws (testing::TestError) { |
| 113 | let mut a = testResolver(); |
| 114 | let program = |
| 115 | "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { set a.value = a.value + n as i32; return a.value; } }"; |
| 116 | let result = try resolveProgramStr(&mut a, program); |
| 117 | // Should reject: instance param type u8 doesn't match trait param type i32. |
| 118 | let err = try expectError(&result); |
| 119 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 120 | } |
| 121 | |
| 122 | /// Duplicate instance declarations for the same (trait, type) pair should be rejected. |
| 123 | @test unsafe fn testResolveInstanceDuplicateRejected() throws (testing::TestError) { |
| 124 | let mut a = testResolver(); |
| 125 | let program = |
| 126 | "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n + 100; return c.value; } }"; |
| 127 | let result = try resolveProgramStr(&mut a, program); |
| 128 | // Should reject: duplicate instance for (Adder, Counter). |
| 129 | try expectErrorKind(&result, resolver::ErrorKind::DuplicateInstance); |
| 130 | } |
| 131 | |
| 132 | /// Trait method receiver must point to the declaring trait type. |
| 133 | @test unsafe fn testResolveTraitReceiverMismatch() throws (testing::TestError) { |
| 134 | let mut a = testResolver(); |
| 135 | let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }"; |
| 136 | let result = try resolveProgramStr(&mut a, program); |
| 137 | try expectErrorKind(&result, resolver::ErrorKind::TraitReceiverMismatch); |
| 138 | } |
| 139 | |
| 140 | /// Using a trait name as a value expression should be rejected. |
| 141 | @test unsafe fn testResolveTraitNameAsValueRejected() throws (testing::TestError) { |
| 142 | let mut a = testResolver(); |
| 143 | let program = |
| 144 | "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }"; |
| 145 | let result = try resolveProgramStr(&mut a, program); |
| 146 | try expectErrorKind(&result, resolver::ErrorKind::UnexpectedTraitName); |
| 147 | } |
| 148 | |
| 149 | /// Cross-module trait: coerce to trait object and dispatch from a different module. |
| 150 | @test unsafe fn testResolveTraitCrossModuleCoercion() throws (testing::TestError) { |
| 151 | let mut a = testResolver(); |
| 152 | |
| 153 | let rootId = try registerModule( |
| 154 | &mut super::MODULE_GRAPH, nil, "root", "export mod defs; mod app;" |
| 155 | ); |
| 156 | let defsId = try registerModule( |
| 157 | &mut super::MODULE_GRAPH, |
| 158 | rootId, |
| 159 | "defs", |
| 160 | "export record Counter { value: i32 } export trait Adder { fn (&mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: &mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }" |
| 161 | ); |
| 162 | let appId = try registerModule( |
| 163 | &mut super::MODULE_GRAPH, |
| 164 | rootId, |
| 165 | "app", |
| 166 | "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: &mut opaque defs::Adder = &mut c; return a.add(5); }" |
| 167 | ); |
| 168 | |
| 169 | let result = try resolveModuleTree(&mut a, rootId); |
| 170 | try expectNoErrors(&result); |
| 171 | } |
| 172 | |
| 173 | /// Instance in a different module from trait and type. |
| 174 | @test unsafe fn testResolveInstanceCrossModule() throws (testing::TestError) { |
| 175 | let mut a = testResolver(); |
| 176 | |
| 177 | let rootId = try registerModule( |
| 178 | &mut super::MODULE_GRAPH, nil, "root", "export mod defs; export mod impls; mod app;" |
| 179 | ); |
| 180 | let defsId = try registerModule( |
| 181 | &mut super::MODULE_GRAPH, |
| 182 | rootId, |
| 183 | "defs", |
| 184 | "export record Counter { value: i32 } export trait Adder { fn (&mut Adder) add(n: i32) -> i32; }" |
| 185 | ); |
| 186 | let implsId = try registerModule( |
| 187 | &mut super::MODULE_GRAPH, |
| 188 | rootId, |
| 189 | "impls", |
| 190 | "use root::defs; instance defs::Adder for defs::Counter { fn (c: &mut defs::Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } }" |
| 191 | ); |
| 192 | let appId = try registerModule( |
| 193 | &mut super::MODULE_GRAPH, |
| 194 | rootId, |
| 195 | "app", |
| 196 | "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: &mut opaque defs::Adder = &mut c; return a.add(5); }" |
| 197 | ); |
| 198 | |
| 199 | let result = try resolveModuleTree(&mut a, rootId); |
| 200 | try expectNoErrors(&result); |
| 201 | } |
| 202 | |
| 203 | /// Calling a mutable-receiver trait method on an immutable trait object |
| 204 | /// must be rejected. |
| 205 | @test unsafe fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) { |
| 206 | let mut a = testResolver(); |
| 207 | let program = |
| 208 | "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { set c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }"; |
| 209 | let result = try resolveProgramStr(&mut a, program); |
| 210 | try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 211 | } |
| 212 | |
| 213 | /// Immutable methods on an immutable trait object should be accepted. |
| 214 | @test unsafe fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) { |
| 215 | let mut a = testResolver(); |
| 216 | let program = |
| 217 | "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }"; |
| 218 | let result = try resolveProgramStr(&mut a, program); |
| 219 | try expectNoErrors(&result); |
| 220 | } |
| 221 | |
| 222 | /// Both mutable and immutable methods on a mutable trait object should work. |
| 223 | @test unsafe fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) { |
| 224 | let mut a = testResolver(); |
| 225 | let program = |
| 226 | "record Counter { value: i32 } trait Ops { fn (&mut Ops) inc(); fn (&Ops) get() -> i32; } instance Ops for Counter { fn (c: &mut Counter) inc() { set c.value = c.value + 1; } fn (c: &Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }"; |
| 227 | let result = try resolveProgramStr(&mut a, program); |
| 228 | try expectNoErrors(&result); |
| 229 | } |
| 230 | |
| 231 | /// Instance method body type must match the trait return type. |
| 232 | /// The trait declares `-> i32` but the body returns `bool`. |
| 233 | @test unsafe fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) { |
| 234 | let mut a = testResolver(); |
| 235 | let program = |
| 236 | "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }"; |
| 237 | let result = try resolveProgramStr(&mut a, program); |
| 238 | let err = try expectError(&result); |
| 239 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 240 | } |
| 241 | |
| 242 | /// Diamond supertrait inheritance: traits B and C both extend A. |
| 243 | /// Declaring them independently should work fine. |
| 244 | @test unsafe fn testResolveTraitDiamondSupertrait() throws (testing::TestError) { |
| 245 | let mut a = testResolver(); |
| 246 | let program = |
| 247 | "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }"; |
| 248 | let result = try resolveProgramStr(&mut a, program); |
| 249 | try expectNoErrors(&result); |
| 250 | } |
| 251 | |
| 252 | /// Diamond supertrait with a combined trait that would cause duplicate |
| 253 | /// method names should be detected. |
| 254 | @test unsafe fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) { |
| 255 | let mut a = testResolver(); |
| 256 | let program = |
| 257 | "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }"; |
| 258 | let result = try resolveProgramStr(&mut a, program); |
| 259 | // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`. |
| 260 | try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("f")); |
| 261 | } |
| 262 | |
| 263 | /// Supertrait instance must exist when declaring a combined trait instance. |
| 264 | @test unsafe fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) { |
| 265 | let mut a = testResolver(); |
| 266 | let program = |
| 267 | "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }"; |
| 268 | let result = try resolveProgramStr(&mut a, program); |
| 269 | try expectErrorKind(&result, resolver::ErrorKind::MissingSupertraitInstance("Base")); |
| 270 | } |
| 271 | |
| 272 | /// Instance method omits return type when the trait declares `-> i32`. |
| 273 | /// This is rejected -- the return type must be stated explicitly. |
| 274 | @test unsafe fn testResolveInstanceReturnTypeOmitted() throws (testing::TestError) { |
| 275 | let mut a = testResolver(); |
| 276 | let program = |
| 277 | "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() { } }"; |
| 278 | let result = try resolveProgramStr(&mut a, program); |
| 279 | let err = try expectError(&result); |
| 280 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 281 | } |
| 282 | |
| 283 | /// Instance method declares throws but the trait method does not throw. |
| 284 | @test unsafe fn testResolveInstanceThrowsMismatchExtra() throws (testing::TestError) { |
| 285 | let mut a = testResolver(); |
| 286 | let program = |
| 287 | "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> i32 throws (E) { return r.x; } }"; |
| 288 | let result = try resolveProgramStr(&mut a, program); |
| 289 | let err = try expectError(&result); |
| 290 | let case resolver::ErrorKind::FnThrowCountMismatch(_) = err.kind |
| 291 | else throw testing::TestError::Failed; |
| 292 | } |
| 293 | |
| 294 | /// Instance method declares a different throws type than the trait. |
| 295 | @test unsafe fn testResolveInstanceThrowsMismatchWrongType() throws (testing::TestError) { |
| 296 | let mut a = testResolver(); |
| 297 | let program = |
| 298 | "union E1 { Fail } union E2 { Oops } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E1); } instance T for R { fn (r: *R) get() -> i32 throws (E2) { return r.x; } }"; |
| 299 | let result = try resolveProgramStr(&mut a, program); |
| 300 | let err = try expectError(&result); |
| 301 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 302 | } |
| 303 | |
| 304 | /// A standalone method takes at most eight declared parameters, as a function does. |
| 305 | /// The receiver is not counted. |
| 306 | @test unsafe fn testResolveMethodParamOverflow() throws (testing::TestError) { |
| 307 | let mut a = testResolver(); |
| 308 | let program = |
| 309 | "record R { x: i32 } fn (r: &R) f(a: i32, b: i32, c: i32, d: i32, e: i32, g: i32, h: i32, i: i32, j: i32) -> i32 { return a; }"; |
| 310 | let result = try resolveProgramStr(&mut a, program); |
| 311 | let err = try expectError(&result); |
| 312 | let case resolver::ErrorKind::FnParamOverflow(_) = err.kind |
| 313 | else throw testing::TestError::Failed; |
| 314 | } |
| 315 | |
| 316 | /// A standalone method with eight declared parameters is accepted. |
| 317 | @test unsafe fn testResolveMethodEightParams() throws (testing::TestError) { |
| 318 | let mut a = testResolver(); |
| 319 | let program = |
| 320 | "record R { x: i32 } fn (r: &R) f(a: i32, b: i32, c: i32, d: i32, e: i32, g: i32, h: i32, i: i32) -> i32 { return a; }"; |
| 321 | let result = try resolveProgramStr(&mut a, program); |
| 322 | try expectNoErrors(&result); |
| 323 | } |
| 324 | |
| 325 | /// Instance method omits throws clause when trait declares throws. |
| 326 | /// This is rejected -- the throws clause must match exactly. |
| 327 | @test unsafe fn testResolveInstanceThrowsOmitted() throws (testing::TestError) { |
| 328 | let mut a = testResolver(); |
| 329 | let program = |
| 330 | "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 { throw E::Fail; return r.x; } }"; |
| 331 | let result = try resolveProgramStr(&mut a, program); |
| 332 | let err = try expectError(&result); |
| 333 | let case resolver::ErrorKind::FnThrowCountMismatch(_) = err.kind |
| 334 | else throw testing::TestError::Failed; |
| 335 | } |
| 336 | |
| 337 | /// Instance method correctly matches the trait's throws clause. |
| 338 | @test unsafe fn testResolveInstanceThrowsMatch() throws (testing::TestError) { |
| 339 | let mut a = testResolver(); |
| 340 | let program = |
| 341 | "union E { Fail } record R { x: i32 } trait T { fn (*T) get() -> i32 throws (E); } instance T for R { fn (r: *R) get() -> i32 throws (E) { throw E::Fail; return r.x; } }"; |
| 342 | let result = try resolveProgramStr(&mut a, program); |
| 343 | try expectNoErrors(&result); |
| 344 | } |
| 345 | |
| 346 | /// Test arithmetic constant folding: add, sub, mul, div. |
| 347 | @test unsafe fn testConstExprArithmetic() throws (testing::TestError) { |
| 348 | try expectConstFold( |
| 349 | "constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B;", 2, 30 |
| 350 | ); |
| 351 | try expectConstFold( |
| 352 | "constant A: i32 = 50; constant B: i32 = 20; constant C: i32 = A - B;", 2, 30 |
| 353 | ); |
| 354 | try expectConstFold( |
| 355 | "constant A: i32 = 6; constant B: i32 = 7; constant C: i32 = A * B;", 2, 42 |
| 356 | ); |
| 357 | try expectConstFold( |
| 358 | "constant A: i32 = 100; constant B: i32 = 5; constant C: i32 = A / B;", 2, 20 |
| 359 | ); |
| 360 | } |
| 361 | |
| 362 | /// Test bitwise constant folding: and, or, xor. |
| 363 | @test unsafe fn testConstExprBitwise() throws (testing::TestError) { |
| 364 | try expectConstFold( |
| 365 | "constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A & B;", 2, 0x0F |
| 366 | ); |
| 367 | try expectConstFold( |
| 368 | "constant A: i32 = 0xF0; constant B: i32 = 0x0F; constant C: i32 = A | B;", 2, 0xFF |
| 369 | ); |
| 370 | try expectConstFold( |
| 371 | "constant A: i32 = 0xFF; constant B: i32 = 0x0F; constant C: i32 = A ^ B;", 2, 0xF0 |
| 372 | ); |
| 373 | } |
| 374 | |
| 375 | /// Test shift constant folding. |
| 376 | @test unsafe fn testConstExprShift() throws (testing::TestError) { |
| 377 | try expectConstFold("constant A: i32 = 1; constant B: i32 = A << 4;", 1, 16); |
| 378 | try expectConstFold("constant A: i32 = 32; constant B: i32 = A >> 2;", 1, 8); |
| 379 | } |
| 380 | |
| 381 | /// Test chained constant expressions (C depends on A + B, D depends on C). |
| 382 | @test unsafe fn testConstExprChained() throws (testing::TestError) { |
| 383 | try expectConstFold( |
| 384 | "constant A: i32 = 10; constant B: i32 = 20; constant C: i32 = A + B; constant D: i32 = C * 2;", |
| 385 | 3, |
| 386 | 60 |
| 387 | ); |
| 388 | } |
| 389 | |
| 390 | /// Test constant expression used as array size. |
| 391 | @test unsafe fn testConstExprAsArraySize() throws (testing::TestError) { |
| 392 | let mut a = testResolver(); |
| 393 | let program = |
| 394 | "constant A: u32 = 2; constant B: u32 = 3; constant SIZE: u32 = A + B; constant ARR: [i32; SIZE] = [1, 2, 3, 4, 5];"; |
| 395 | let result = try resolveProgramStr(&mut a, program); |
| 396 | try expectNoErrors(&result); |
| 397 | |
| 398 | let arrStmt = try getBlockStmt(result.root, 3); |
| 399 | let sym = resolver::symbolFor(&a, arrStmt) else throw testing::TestError::Failed; |
| 400 | let case resolver::SymbolData::Constant { type: resolver::Type::Array(arrType), .. } = |
| 401 | a.symbols[*sym].data else throw testing::TestError::Failed; |
| 402 | try testing::expect(arrType.length == 5); |
| 403 | } |
| 404 | |
| 405 | /// Test cross-module constant expression: a constant in one module references |
| 406 | /// a constant from another module via scope access. |
| 407 | @test unsafe fn testCrossModuleConstExpr() throws (testing::TestError) { |
| 408 | let mut a = testResolver(); |
| 409 | |
| 410 | let rootId = try registerModule( |
| 411 | &mut super::MODULE_GRAPH, nil, "root", "export mod consts; mod app;" |
| 412 | ); |
| 413 | let constsId = try registerModule( |
| 414 | &mut super::MODULE_GRAPH, rootId, "consts", "export constant BASE: i32 = 100;" |
| 415 | ); |
| 416 | let appId = try registerModule( |
| 417 | &mut super::MODULE_GRAPH, |
| 418 | rootId, |
| 419 | "app", |
| 420 | "use root::consts; constant DERIVED: i32 = consts::BASE + 50;" |
| 421 | ); |
| 422 | |
| 423 | let result = try resolveModuleTree(&mut a, rootId); |
| 424 | try expectNoErrors(&result); |
| 425 | } |
| 426 | |
| 427 | /// Test cross-module constant expression used as array size. |
| 428 | @test unsafe fn testCrossModuleConstExprArraySize() throws (testing::TestError) { |
| 429 | let mut a = testResolver(); |
| 430 | |
| 431 | let rootId = try registerModule( |
| 432 | &mut super::MODULE_GRAPH, nil, "root", "export mod consts; mod app;" |
| 433 | ); |
| 434 | let constsId = try registerModule( |
| 435 | &mut super::MODULE_GRAPH, |
| 436 | rootId, |
| 437 | "consts", |
| 438 | "export constant WIDTH: u32 = 8; export constant HEIGHT: u32 = 4;" |
| 439 | ); |
| 440 | let appId = try registerModule( |
| 441 | &mut super::MODULE_GRAPH, |
| 442 | rootId, |
| 443 | "app", |
| 444 | "use root::consts; constant TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = [0; TOTAL];" |
| 445 | ); |
| 446 | |
| 447 | let result = try resolveModuleTree(&mut a, rootId); |
| 448 | try expectNoErrors(&result); |
| 449 | } |
| 450 | |
| 451 | /// Test that non-constant expressions in constant declarations are still rejected. |
| 452 | @test unsafe fn testConstExprNonConstRejected() throws (testing::TestError) { |
| 453 | let mut a = testResolver(); |
| 454 | let program = "fn value() -> i32 { return 1; } constant BAD: i32 = value() + 1;"; |
| 455 | let result = try resolveProgramStr(&mut a, program); |
| 456 | let err = try expectError(&result); |
| 457 | let case resolver::ErrorKind::ConstExprRequired = err.kind |
| 458 | else throw testing::TestError::Failed; |
| 459 | } |
| 460 | |
| 461 | /// Test unary negation in constant expressions. |
| 462 | @test unsafe fn testConstExprUnaryNeg() throws (testing::TestError) { |
| 463 | let mut a = testResolver(); |
| 464 | let program = "constant A: i32 = 10; constant B: i32 = -A;"; |
| 465 | let result = try resolveProgramStr(&mut a, program); |
| 466 | try expectNoErrors(&result); |
| 467 | } |
| 468 | |
| 469 | /// Test unary not in constant expressions. |
| 470 | @test unsafe fn testConstExprUnaryNot() throws (testing::TestError) { |
| 471 | let mut a = testResolver(); |
| 472 | let program = "constant A: bool = true; constant B: bool = not A;"; |
| 473 | let result = try resolveProgramStr(&mut a, program); |
| 474 | try expectNoErrors(&result); |
| 475 | } |
| 476 | |
| 477 | /// Test `as` casts in constant expressions: widening, narrowing, sign changes, chaining. |
| 478 | @test unsafe fn testConstExprCast() throws (testing::TestError) { |
| 479 | try expectConstFold("constant A: i32 = 42; constant B: u64 = A as u64;", 1, 42); |
| 480 | try expectConstFold("constant A: u64 = 10; constant B: u8 = A as u8;", 1, 10); |
| 481 | try expectConstFold("constant A: i32 = 7; constant B: u32 = A as u32;", 1, 7); |
| 482 | try expectConstFold("constant A: u32 = 100; constant B: i32 = A as i32;", 1, 100); |
| 483 | try expectConstFold("constant A: u8 = 5; constant B: u64 = (A as u32) as u64;", 1, 5); |
| 484 | try expectConstFold( |
| 485 | "constant A: u8 = 3; constant B: u8 = 4; constant C: i32 = (A as i32) + (B as i32);", 2, 7 |
| 486 | ); |
| 487 | // Cast of unsuffixed literal arithmetic. |
| 488 | try expectConstFold("constant A: u32 = (3 + 4) as u32;", 0, 7); |
| 489 | try expectConstFold("constant A: u32 = ((3 + 4) as u64) as u32;", 0, 7); |
| 490 | try expectConstFold("constant A: u32 = (3 + 4) as u32 + 1;", 0, 8); |
| 491 | try expectConstFold("constant A: i32 = (2 as i32) * (3 + 4);", 0, 14); |
| 492 | } |
| 493 | |
| 494 | /// Test `as` cast in constant expressions used as array size. |
| 495 | @test unsafe fn testConstExprCastAsArraySize() throws (testing::TestError) { |
| 496 | let mut a = testResolver(); |
| 497 | let program = |
| 498 | "constant LEN: u64 = 4; constant SIZE: u32 = LEN as u32; constant ARR: [i32; SIZE] = [1, 2, 3, 4];"; |
| 499 | let result = try resolveProgramStr(&mut a, program); |
| 500 | try expectNoErrors(&result); |
| 501 | |
| 502 | let arrStmt = try getBlockStmt(result.root, 2); |
| 503 | let sym = resolver::symbolFor(&a, arrStmt) else throw testing::TestError::Failed; |
| 504 | let case resolver::SymbolData::Constant { type: resolver::Type::Array(arrType), .. } = |
| 505 | a.symbols[*sym].data else throw testing::TestError::Failed; |
| 506 | try testing::expect(arrType.length == 4); |
| 507 | } |
| 508 | |
| 509 | /// Test unsuffixed integer literals in constant expressions. |
| 510 | @test unsafe fn testConstExprUnsuffixedLiterals() throws (testing::TestError) { |
| 511 | try expectConstFold("constant A: u32 = 4 * 4;", 0, 16); |
| 512 | try expectConstFold("constant B: u32 = 10; constant C: u32 = B * 2;", 1, 20); |
| 513 | try expectConstFold("constant D: u32 = 3 + 7;", 0, 10); |
| 514 | try expectConstFold("constant E: u32 = 2 * 3 + 4;", 0, 10); |
| 515 | try expectConstFold("constant F: i32 = -(3 + 4);", 0, 7); |
| 516 | } |
| 517 | |
| 518 | /// References cannot escape through return types. |
| 519 | @test unsafe fn testRefReturnRejected() throws (testing::TestError) { |
| 520 | let programs = &[ |
| 521 | "record Marker: Once {} fn bad(value: &u32) -> &u32 { return value; }", |
| 522 | "record R: Copy { n: u32 } fn (r: &R) bad() -> &u32 { return &r.n; }", |
| 523 | "record R: Copy { n: u32 } fn (r: &mut R) bad() -> &mut u32 { return &mut r.n; }", |
| 524 | "record R: Copy { n: u32 } fn (r: &R) bad() -> &[u32] { return &[1 as u32]; }", |
| 525 | "trait T { fn (&T) bad() -> &u32; }", |
| 526 | "trait T { fn (&T) bad() -> *u32; } record R: Copy { n: u32 } instance T for R { fn (r: &R) bad() -> &u32 { return &r.n; } }", |
| 527 | "trait T {} record R: Copy { n: u32 } fn (r: &R) bad(p: &opaque T) -> &opaque T { return p; }", |
| 528 | "record R: Copy { n: u32 } fn (r: &R) bad() throws (&u32) { throw &r.n; }", |
| 529 | "trait T { fn (&T) bad() throws (&u32); }", |
| 530 | "trait T { fn (&T) bad() throws (u32); } record R: Copy { n: u32 } instance T for R { fn (r: &R) bad() throws (&u32) { throw &r.n; } }", |
| 531 | ]; |
| 532 | for program in programs { |
| 533 | let mut a = testResolver(); |
| 534 | let result = try resolveProgramStr(&mut a, program); |
| 535 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 536 | } |
| 537 | } |
| 538 | |
| 539 | /// Case-pattern fallbacks must terminate instead of synthesizing bindings. |
| 540 | @test unsafe fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) { |
| 541 | let mut a = testResolver(); |
| 542 | let program = |
| 543 | "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }"; |
| 544 | let result = try resolveProgramStr(&mut a, program); |
| 545 | try expectErrorKind(&result, resolver::ErrorKind::LinearLetElseMustTerminate); |
| 546 | } |
| 547 | |
| 548 | /// Case bindings are unavailable on the pattern-failure path. |
| 549 | @test unsafe fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) { |
| 550 | let mut a = testResolver(); |
| 551 | let program = |
| 552 | "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }"; |
| 553 | let result = try resolveProgramStr(&mut a, program); |
| 554 | try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("item")); |
| 555 | } |
| 556 | |
| 557 | /// Unsafe pointer dereference requires an unsafe declaration. |
| 558 | @test unsafe fn testUnsafePointerOperationRejected() throws (testing::TestError) { |
| 559 | let mut a = testResolver(); |
| 560 | let program = |
| 561 | "record Marker: Once {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }"; |
| 562 | let result = try resolveProgramStr(&mut a, program); |
| 563 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 564 | } |
| 565 | |
| 566 | /// Unsafe pointers remain freely copyable inside an unsafe declaration. |
| 567 | @test unsafe fn testUnsafePointerOperationAllowed() throws (testing::TestError) { |
| 568 | let program = |
| 569 | "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; }"; |
| 570 | try expectAnalyzeOk(program); |
| 571 | } |
| 572 | |
| 573 | /// Safe code cannot call a function that accepts unsafe operations. |
| 574 | @test unsafe fn testUnsafeFunctionCallRejected() throws (testing::TestError) { |
| 575 | let mut a = testResolver(); |
| 576 | let program = |
| 577 | "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }"; |
| 578 | let result = try resolveProgramStr(&mut a, program); |
| 579 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 580 | } |
| 581 | |
| 582 | /// Unsafe function values retain their call-site safety requirement. |
| 583 | @test unsafe fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) { |
| 584 | let mut a = testResolver(); |
| 585 | let program = |
| 586 | "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }"; |
| 587 | let result = try resolveProgramStr(&mut a, program); |
| 588 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 589 | } |
| 590 | |
| 591 | /// References cannot be embedded in aggregate fields. |
| 592 | @test unsafe fn testRefFieldRejected() throws (testing::TestError) { |
| 593 | let mut a = testResolver(); |
| 594 | let program = "record Marker: Once {} record Bad { value: &u32 }"; |
| 595 | let result = try resolveProgramStr(&mut a, program); |
| 596 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 597 | } |
| 598 | |
| 599 | /// Trait methods may use reference receivers. |
| 600 | @test unsafe fn testTraitRefReceiver() throws (testing::TestError) { |
| 601 | let program = |
| 602 | "record Marker: Once {} record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: &Value) get() -> i32 { return value.number; } } fn inspect(object: &opaque Read) -> i32 { return object.get(); } fn call(value: &Value) -> i32 { return inspect(value); }"; |
| 603 | try expectAnalyzeOk(program); |
| 604 | } |
| 605 | |
| 606 | /// Trait implementations must preserve the receiver pointer class. |
| 607 | @test unsafe fn testTraitReceiverClassMismatch() throws (testing::TestError) { |
| 608 | let mut a = testResolver(); |
| 609 | let program = |
| 610 | "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }"; |
| 611 | let result = try resolveProgramStr(&mut a, program); |
| 612 | try expectErrorKind(&result, resolver::ErrorKind::TraitReceiverMismatch); |
| 613 | } |
| 614 | |
| 615 | /// Unmarked composite values may be discarded. |
| 616 | @test unsafe fn testAffineCompositeMayBeDiscarded() throws (testing::TestError) { |
| 617 | let program = "record Value { number: u32 } fn run() { let value = Value { number: 1 }; }"; |
| 618 | try expectAnalyzeOk(program); |
| 619 | } |
| 620 | |
| 621 | /// A by-value use moves an unmarked composite value. |
| 622 | @test unsafe fn testAffineCompositeUseAfterMoveRejected() throws (testing::TestError) { |
| 623 | let mut a = testResolver(); |
| 624 | let program = |
| 625 | "record Value { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }"; |
| 626 | let result = try resolveProgramStr(&mut a, program); |
| 627 | try expectErrorKind(&result, resolver::ErrorKind::AffineUseAfterMove("value")); |
| 628 | } |
| 629 | |
| 630 | /// Affine values may move on only one branch when not used later. |
| 631 | @test unsafe fn testAffineConditionalMoveMayBeDiscarded() throws (testing::TestError) { |
| 632 | let program = |
| 633 | "record Value { number: u32 } fn take(value: Value) {} fn run(condition: bool) { let value = Value { number: 1 }; if condition { take(value); } }"; |
| 634 | try expectAnalyzeOk(program); |
| 635 | } |
| 636 | |
| 637 | /// A `Copy` composite remains available after a by-value use. |
| 638 | @test unsafe fn testCopyCompositeMayBeReused() throws (testing::TestError) { |
| 639 | let program = |
| 640 | "record Value: Copy { number: u32 } fn take(value: Value) {} fn run() { let value = Value { number: 1 }; take(value); take(value); }"; |
| 641 | try expectAnalyzeOk(program); |
| 642 | } |
| 643 | |
| 644 | /// A `Copy` composite may contain only copy values. |
| 645 | @test unsafe fn testCopyCompositeRejectsAffineField() throws (testing::TestError) { |
| 646 | let mut a = testResolver(); |
| 647 | let program = "record Inner { number: u32 } record Outer: Copy { inner: Inner }"; |
| 648 | let result = try resolveProgramStr(&mut a, program); |
| 649 | try expectErrorKind(&result, resolver::ErrorKind::CopyContainsNonCopy); |
| 650 | } |
| 651 | |
| 652 | /// A composite cannot carry conflicting ownership markers. |
| 653 | @test unsafe fn testConflictingOwnershipMarkersRejected() throws (testing::TestError) { |
| 654 | let mut a = testResolver(); |
| 655 | let program = "record Value: Copy + Once { number: u32 }"; |
| 656 | let result = try resolveProgramStr(&mut a, program); |
| 657 | try expectErrorKind(&result, resolver::ErrorKind::ConflictingOwnershipMarkers); |
| 658 | } |
| 659 | |
| 660 | /// Linear composites still require one consuming use. |
| 661 | @test unsafe fn testLinearCompositeMustBeConsumed() throws (testing::TestError) { |
| 662 | let mut a = testResolver(); |
| 663 | let program = |
| 664 | "record Token: Once { number: u32 } fn run() { let token = Token { number: 1 }; }"; |
| 665 | let result = try resolveProgramStr(&mut a, program); |
| 666 | try expectErrorKind(&result, resolver::ErrorKind::LinearNotConsumed("token")); |
| 667 | } |
| 668 | |
| 669 | /// A propagating `try` leaves the function on failure, so a live linear value must already be |
| 670 | /// consumed, as at a `throw`. |
| 671 | @test unsafe fn testTryPropagationRequiresLinearConsumed() throws (testing::TestError) { |
| 672 | for program in [ |
| 673 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() throws (E) { let x = F::Open(1); try may(); close(x); }", |
| 674 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() -> u32 throws (E) { let x = F::Open(1); let v = try mayv(); close(x); return v; }", |
| 675 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() throws (E) { let x = F::Open(1); for i in 0..2 { try may(); } close(x); }", |
| 676 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f(x: F) throws (E) { try may(); close(x); }", |
| 677 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() throws (E) { let x = F::Open(1); throw E::Bad; }", |
| 678 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() throws (E) { let x = F::Open(1); try may() catch e { throw e; }; close(x); }", |
| 679 | ] { |
| 680 | let mut a = testResolver(); |
| 681 | let result = try resolveProgramStr(&mut a, program); |
| 682 | let error = try expectError(&result); |
| 683 | let case resolver::ErrorKind::LinearNotConsumed(_) = error.kind |
| 684 | else throw testing::TestError::Failed; |
| 685 | } |
| 686 | } |
| 687 | |
| 688 | /// A `try` that cannot leave the function on failure, or leaves with nothing live, is accepted. |
| 689 | @test unsafe fn testTryWithLinearConsumedAllowed() throws (testing::TestError) { |
| 690 | for program in [ |
| 691 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() throws (E) { let x = F::Open(1); close(x); try may(); }", |
| 692 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn take(x: F) throws (E) { close(x); } fn f() throws (E) { let x = F::Open(1); try take(x); }", |
| 693 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() { let x = F::Open(1); let y = try? mayv(); close(x); }", |
| 694 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() { let x = F::Open(1); try! may(); close(x); }", |
| 695 | "union F: Once { Open(u32) } union E: Copy { Bad } fn close(f: F) { match f { case F::Open(_) => {} } } fn may() throws (E) {} fn mayv() -> u32 throws (E) { return 1; } fn f() { let x = F::Open(1); try may() catch {}; close(x); }", |
| 696 | ] { |
| 697 | let mut a = testResolver(); |
| 698 | let result = try resolveProgramStr(&mut a, program); |
| 699 | try expectNoErrors(&result); |
| 700 | } |
| 701 | } |
| 702 | |
| 703 | /// The compiler-known marker cannot be derived more than once. |
| 704 | @test unsafe fn testDuplicateOnceMarkerRejected() throws (testing::TestError) { |
| 705 | let mut a = testResolver(); |
| 706 | let program = "record Token: Once + Once { value: u32 }"; |
| 707 | let result = try resolveProgramStr(&mut a, program); |
| 708 | try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("Once")); |
| 709 | } |
| 710 | |
| 711 | /// Stack storage cannot produce a safe stored pointer or slice. |
| 712 | @test unsafe fn testStackPointerRejected() throws (testing::TestError) { |
| 713 | let programs = &[ |
| 714 | "fn run() { let value: u32 = 0; let pointer: *u32 = &value; }", |
| 715 | "fn run() -> *u32 { let value: u32 = 0; return &value; }", |
| 716 | "fn run(value: u32) -> *u32 { return &value; }", |
| 717 | "record Cell { value: u32 } fn run() { let cell = Cell { value: 1 }; let pointer: *u32 = &cell.value; }", |
| 718 | "fn run() { let values = [1, 2]; let pointer: *i32 = &values[0]; }", |
| 719 | "fn run() { let values = [1, 2]; let slice: *[i32] = &values[..]; }", |
| 720 | "fn run(value: i32) { let slice: *[i32] = &[value]; }", |
| 721 | "fn run(value: &u32) -> *u32 { return value; }", |
| 722 | "fn run(value: &u32) -> *u32 { return &*value; }", |
| 723 | "fn run(values: &[u32]) -> *[u32] { return values; }", |
| 724 | "fn run(values: &[u32]) -> *[u32] { return &values[..]; }", |
| 725 | "fn run(values: &[u32]) -> *u32 { return values.ptr; }", |
| 726 | "fn run() -> *i32 { return &[1, 2][0]; }", |
| 727 | "fn run() -> *[i32] { return &[1, 2][..]; }", |
| 728 | "fn run(value: *u32) -> **u32 { return &value; }", |
| 729 | "fn run(values: *[u32]) -> *u32 { return &values.len; }", |
| 730 | "unsafe fn run(value: *unsafe u32) -> *u32 { return &*value; }", |
| 731 | "fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }", |
| 732 | "record Cell { value: u32 } fn run(value: &Cell) -> *u32 { return &value.value; }", |
| 733 | "record Cell { value: *u32 } fn run(value: &u32) -> Cell { return Cell { value }; }", |
| 734 | "fn run(value: &u32) -> *[u32] { return @sliceOf(value, 1); }", |
| 735 | ]; |
| 736 | for program in programs { |
| 737 | let mut resolver = testResolver(); |
| 738 | let result = try resolveProgramStr(&mut resolver, program); |
| 739 | try expectError(&result); |
| 740 | } |
| 741 | } |
| 742 | |
| 743 | /// Stack values can be borrowed for a call. |
| 744 | @test unsafe fn testStackBorrowAllowed() throws (testing::TestError) { |
| 745 | try expectAnalyzeOk( |
| 746 | "fn read(value: &u32) -> u32 { return *value; } fn run() -> u32 { let value: u32 = 7; return read(&value); }" |
| 747 | ); |
| 748 | try expectAnalyzeOk( |
| 749 | "fn write(values: &mut [u32]) { set values[0] = 7; } fn run() { let mut values: [u32; 2] = [1, 2]; write(&mut values[..]); }" |
| 750 | ); |
| 751 | } |
| 752 | |
| 753 | /// Raw pointers and slices can be borrowed in an unsafe context. |
| 754 | @test unsafe fn testImplicitRawBorrowAllowed() throws (testing::TestError) { |
| 755 | let programs = &[ |
| 756 | "fn read(p: &u32) -> u32 { return *p; } unsafe fn run(p: *unsafe u32) -> u32 { return read(p); }", |
| 757 | "fn write(p: &mut u32) { set *p = 7; } fn run(p: *unsafe mut u32) { unsafe { write(p); write(p); } }", |
| 758 | "fn read(p: &[u32]) -> u32 { return p[0]; } unsafe fn run(p: *unsafe [u32]) -> u32 { return read(p); }", |
| 759 | "fn write(p: &mut [u32]) { set p[0] = 7; } unsafe fn run(p: *unsafe mut [u32]) { write(p); write(p); }", |
| 760 | "fn read(p: &u32) {} unsafe fn run(p: *unsafe mut u32) { read(p); }", |
| 761 | "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} unsafe fn run(p: *unsafe opaque Read) { read(p); }", |
| 762 | ]; |
| 763 | for program in programs { |
| 764 | try expectAnalyzeOk(program); |
| 765 | } |
| 766 | } |
| 767 | |
| 768 | /// An implicit borrow of raw storage requires an unsafe context. |
| 769 | @test unsafe fn testImplicitRawBorrowRequiresUnsafe() throws (testing::TestError) { |
| 770 | let programs = &[ |
| 771 | "fn read(p: &u32) {} fn run(p: *unsafe u32) { read(p); }", |
| 772 | "fn write(p: &mut u32) {} fn run(p: *unsafe mut u32) { write(p); }", |
| 773 | "fn read(p: &[u32]) {} fn run(p: *unsafe [u32]) { read(p); }", |
| 774 | "fn write(p: &mut [u32]) {} fn run(p: *unsafe mut [u32]) { write(p); }", |
| 775 | "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} fn run(p: *unsafe opaque Read) { read(p); }", |
| 776 | "fn read(p: &u32) {} fn run(p: *unsafe u32) { unsafe { read(p); } read(p); }", |
| 777 | ]; |
| 778 | for program in programs { |
| 779 | let mut a = testResolver(); |
| 780 | let result = try resolveProgramStr(&mut a, program); |
| 781 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 782 | } |
| 783 | } |
| 784 | |
| 785 | /// Raw borrows preserve mutability, storage type, and ownership constraints. |
| 786 | @test unsafe fn testImplicitRawBorrowPreservesTypes() throws (testing::TestError) { |
| 787 | let programs = &[ |
| 788 | "fn write(p: &mut u32) {} unsafe fn run(p: *unsafe u32) { write(p); }", |
| 789 | "fn write(p: &mut [u32]) {} unsafe fn run(p: *unsafe [u32]) { write(p); }", |
| 790 | "fn read(p: &u64) {} unsafe fn run(p: *unsafe u32) { read(p); }", |
| 791 | "fn read(p: &[u64]) {} unsafe fn run(p: *unsafe [u32]) { read(p); }", |
| 792 | "fn take(p: *u32) {} unsafe fn run(p: *unsafe u32) { take(p); }", |
| 793 | "fn take(p: *[u32]) {} unsafe fn run(p: *unsafe [u32]) { take(p); }", |
| 794 | "fn read(p: &*u32) {} unsafe fn run(p: *unsafe *unsafe u32) { read(p); }", |
| 795 | ]; |
| 796 | for program in programs { |
| 797 | let mut a = testResolver(); |
| 798 | let result = try resolveProgramStr(&mut a, program); |
| 799 | let err = try expectError(&result); |
| 800 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind |
| 801 | else throw testing::TestError::Failed; |
| 802 | } |
| 803 | } |
| 804 | |
| 805 | /// Implicit raw borrows retain the call's exclusive-borrow checks. |
| 806 | @test unsafe fn testImplicitRawBorrowConflict() throws (testing::TestError) { |
| 807 | let mut a = testResolver(); |
| 808 | let result = try resolveProgramStr( |
| 809 | &mut a, |
| 810 | "fn useBoth(a: &mut u32, b: &u32) {} unsafe fn run(p: *unsafe mut u32) { useBoth(p, p); }" |
| 811 | ); |
| 812 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("p")); |
| 813 | } |
| 814 | |
| 815 | /// Unsafe declarations can store raw pointers to stack values. |
| 816 | @test unsafe fn testUnsafeStackPointerAllowed() throws (testing::TestError) { |
| 817 | try expectAnalyzeOk( |
| 818 | "unsafe fn run() { let mut value: u32 = 0; let pointer: *unsafe mut u32 = &mut value as *unsafe mut u32; set *pointer = 7; }" |
| 819 | ); |
| 820 | try expectAnalyzeOk( |
| 821 | "unsafe fn run() { let mut values: [u32; 2] = [1, 2]; let slice: *unsafe mut [u32] = &mut values[..] as *unsafe mut [u32]; set slice[0] = 7; }" |
| 822 | ); |
| 823 | try expectAnalyzeOk( |
| 824 | "unsafe fn run() { let value: u32 = 7; let pointer: *unsafe u32 = &value; }" |
| 825 | ); |
| 826 | try expectAnalyzeOk( |
| 827 | "unsafe fn run() { let values: [u32; 2] = [1, 2]; let slice: *unsafe [u32] = &values[..]; }" |
| 828 | ); |
| 829 | } |
| 830 | |
| 831 | /// Permanent storage can produce safe stored pointers and slices. |
| 832 | @test unsafe fn testPermanentPointerAllowed() throws (testing::TestError) { |
| 833 | try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }"); |
| 834 | try expectAnalyzeOk( |
| 835 | "static VALUES: [u32; 2] = [1, 2]; fn run() -> *[u32] { return &VALUES[..]; }" |
| 836 | ); |
| 837 | try expectAnalyzeOk("fn run() -> *[u32] { return &[1, 2]; }"); |
| 838 | try expectAnalyzeOk("fn run(value: *u32) -> *u32 { return &*value; }"); |
| 839 | try expectAnalyzeOk("fn run(values: *[u32]) -> *[u32] { return &values[..]; }"); |
| 840 | try expectAnalyzeOk( |
| 841 | "record Cell { value: u32 } fn run(value: *Cell) -> *u32 { return &value.value; }" |
| 842 | ); |
| 843 | try expectAnalyzeOk("fn run(values: *[u32]) -> *u32 { return &values[0]; }"); |
| 844 | try expectAnalyzeOk("unsafe fn run(values: *[u32]) -> *u32 { return values.ptr; }"); |
| 845 | try expectAnalyzeOk("unsafe fn run(value: *u32) -> *[u32] { return @sliceOf(value, 1); }"); |
| 846 | } |
| 847 | |
| 848 | /// References are rejected from every nested or storable type position. |
| 849 | @test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) { |
| 850 | { |
| 851 | let mut a = testResolver(); |
| 852 | let program = "record Marker: Once {} union Bad { Value(&u32) }"; |
| 853 | let result = try resolveProgramStr(&mut a, program); |
| 854 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 855 | } |
| 856 | { |
| 857 | let mut a = testResolver(); |
| 858 | let program = "record Marker: Once {} fn bad(value: *unsafe &u32) {}"; |
| 859 | let result = try resolveProgramStr(&mut a, program); |
| 860 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 861 | } |
| 862 | { |
| 863 | let mut a = testResolver(); |
| 864 | let program = "record Marker: Once {} static BAD: &u32 = undefined;"; |
| 865 | let result = try resolveProgramStr(&mut a, program); |
| 866 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 867 | } |
| 868 | { |
| 869 | let mut a = testResolver(); |
| 870 | let program = "record Marker: Once {} fn bad(callback: fn() -> &u32) {}"; |
| 871 | let result = try resolveProgramStr(&mut a, program); |
| 872 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 873 | } |
| 874 | } |
| 875 | |
| 876 | /// Optional and array parameters hold references at their region positions. |
| 877 | @test unsafe fn testNestedRefParametersAllowed() throws (testing::TestError) { |
| 878 | try expectAnalyzeOk( |
| 879 | "fn optional(value: ?&u32) -> u32 { if let v = value { return *v; } return 0; }" |
| 880 | ); |
| 881 | try expectAnalyzeOk("fn array(values: [&u32; 2]) -> u32 { return *values[0] + *values[1]; }"); |
| 882 | } |
| 883 | |
| 884 | /// Function pointer parameter references remain call-scoped and valid. |
| 885 | @test unsafe fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) { |
| 886 | let program = |
| 887 | "record Marker: Once {} fn invoke(callback: fn(&u32), value: &u32) { callback(value); }"; |
| 888 | try expectAnalyzeOk(program); |
| 889 | } |
| 890 | |
| 891 | /// Pointer and slice casts cannot change reference ownership. |
| 892 | @test unsafe fn testRefCastClassPreserved() throws (testing::TestError) { |
| 893 | { |
| 894 | let mut a = testResolver(); |
| 895 | let program = "record Marker: Once {} fn cast(value: &u32) { value as *u32; }"; |
| 896 | let result = try resolveProgramStr(&mut a, program); |
| 897 | let err = try expectError(&result); |
| 898 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind |
| 899 | else throw testing::TestError::Failed; |
| 900 | } |
| 901 | { |
| 902 | let mut a = testResolver(); |
| 903 | let program = "record Marker: Once {} fn cast(values: &[u32]) { values as *[u32]; }"; |
| 904 | let result = try resolveProgramStr(&mut a, program); |
| 905 | let err = try expectError(&result); |
| 906 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind |
| 907 | else throw testing::TestError::Failed; |
| 908 | } |
| 909 | } |
| 910 | |
| 911 | /// Every operation that interprets an unsafe address requires an unsafe declaration. |
| 912 | @test unsafe fn testUnsafePointerOperationsRejected() throws (testing::TestError) { |
| 913 | { |
| 914 | let mut a = testResolver(); |
| 915 | let program = |
| 916 | "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }"; |
| 917 | let result = try resolveProgramStr(&mut a, program); |
| 918 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 919 | } |
| 920 | { |
| 921 | let mut a = testResolver(); |
| 922 | let program = |
| 923 | "record Marker: Once {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }"; |
| 924 | let result = try resolveProgramStr(&mut a, program); |
| 925 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 926 | } |
| 927 | { |
| 928 | let mut a = testResolver(); |
| 929 | let program = |
| 930 | "record Marker: Once {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }"; |
| 931 | let result = try resolveProgramStr(&mut a, program); |
| 932 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 933 | } |
| 934 | { |
| 935 | let mut a = testResolver(); |
| 936 | let program = |
| 937 | "record Marker: Once {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }"; |
| 938 | let result = try resolveProgramStr(&mut a, program); |
| 939 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 940 | } |
| 941 | { |
| 942 | let mut a = testResolver(); |
| 943 | let program = |
| 944 | "record Marker: Once {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }"; |
| 945 | let result = try resolveProgramStr(&mut a, program); |
| 946 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 947 | } |
| 948 | { |
| 949 | let mut a = testResolver(); |
| 950 | let program = |
| 951 | "record Marker: Once {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }"; |
| 952 | let result = try resolveProgramStr(&mut a, program); |
| 953 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 954 | } |
| 955 | { |
| 956 | let mut a = testResolver(); |
| 957 | let program = |
| 958 | "record Marker: Once {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }"; |
| 959 | let result = try resolveProgramStr(&mut a, program); |
| 960 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 961 | } |
| 962 | } |
| 963 | |
| 964 | /// Pointer offsets require an unsafe function for either operand order. |
| 965 | @test unsafe fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) { |
| 966 | let programs = &[ |
| 967 | "fn run(p: *u8) -> *u8 { return p + 1; }", |
| 968 | "fn run(p: *u8) -> *u8 { return 1 + p; }", |
| 969 | "fn run(p: *u8) -> *u8 { return p - 1; }", |
| 970 | "fn run(input: *mut u8) { let mut p = input; set p += 1; }", |
| 971 | "static DATA: [u8; 1] = [42]; fn run() -> u8 { let p = &DATA[0]; return *(p + 1); }", |
| 972 | ]; |
| 973 | for program in programs { |
| 974 | let mut a = testResolver(); |
| 975 | let result = try resolveProgramStr(&mut a, program); |
| 976 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 977 | } |
| 978 | try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return p + 1; }"); |
| 979 | try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return 1 + p; }"); |
| 980 | try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut u8 { return p - 1; }"); |
| 981 | try expectAnalyzeOk("fn run(value: u32) -> u32 { return value + 1; }"); |
| 982 | } |
| 983 | |
| 984 | /// Casts that reinterpret storage require an unsafe function. |
| 985 | @test unsafe fn testStorageCastsRequireUnsafe() throws (testing::TestError) { |
| 986 | let programs = &[ |
| 987 | "fn run(p: *u8) -> *u64 { return p as *u64; }", |
| 988 | "fn run(p: &u8) -> u64 { return *(p as &u64); }", |
| 989 | "fn run(p: *mut u8) -> *mut u64 { return p as *mut u64; }", |
| 990 | "fn run(p: *opaque) -> *u64 { return p as *u64; }", |
| 991 | "fn run(p: **u8) -> **u64 { return p as **u64; }", |
| 992 | "fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }", |
| 993 | "fn run(s: *[opaque]) -> *[u64] { return s as *[u64]; }", |
| 994 | "fn run(s: &mut [u64]) { let _ = s as &mut [u8]; }", |
| 995 | "static DATA: [u8; 1] = [42]; fn run() -> u64 { return *(&DATA[0] as *u64); }", |
| 996 | ]; |
| 997 | for program in programs { |
| 998 | let mut a = testResolver(); |
| 999 | let result = try resolveProgramStr(&mut a, program); |
| 1000 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1001 | } |
| 1002 | try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u64 { return p as *u64; }"); |
| 1003 | try expectAnalyzeOk("unsafe fn run(p: &u8) -> u64 { return *(p as &u64); }"); |
| 1004 | try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }"); |
| 1005 | try expectAnalyzeOk("fn run(p: *u8) -> *u8 { return p as *u8; }"); |
| 1006 | try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p as *opaque; }"); |
| 1007 | try expectAnalyzeOk("fn run(s: *[u8]) -> *[opaque] { return s as *[opaque]; }"); |
| 1008 | try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p as *u8; }"); |
| 1009 | } |
| 1010 | |
| 1011 | /// Explicit slice bounds require an unsafe function. |
| 1012 | @test unsafe fn testSliceConstructionRequiresUnsafe() throws (testing::TestError) { |
| 1013 | let programs = &[ |
| 1014 | "fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }", |
| 1015 | "fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }", |
| 1016 | "fn run(p: &u8) -> u8 { return @sliceOf(p, 100)[99]; }", |
| 1017 | "fn run(p: &mut u8) { set @sliceOf(p, 100)[99] = 1; }", |
| 1018 | "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = @sliceOf(&DATA[0], 100); return s[99]; }", |
| 1019 | ]; |
| 1020 | for program in programs { |
| 1021 | let mut a = testResolver(); |
| 1022 | let result = try resolveProgramStr(&mut a, program); |
| 1023 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1024 | } |
| 1025 | try expectAnalyzeOk("unsafe fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }"); |
| 1026 | try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }"); |
| 1027 | try expectAnalyzeOk("unsafe fn run(p: &u8) -> u8 { return @sliceOf(p, 1)[0]; }"); |
| 1028 | try expectAnalyzeOk("fn run(s: *[u8]) -> *[u8] { return &s[..]; }"); |
| 1029 | } |
| 1030 | |
| 1031 | /// Slice header writes and mutable field borrows require an unsafe function. |
| 1032 | @test unsafe fn testSliceHeaderMutationRequiresUnsafe() throws (testing::TestError) { |
| 1033 | let programs = &[ |
| 1034 | "fn run(s: *mut [u8]) { set s.len = 100; }", |
| 1035 | "fn run(s: *mut [u8]) { set s.cap = 100; }", |
| 1036 | "fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }", |
| 1037 | "fn run(s: *mut [u8]) { set s.len += 1; }", |
| 1038 | "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.len); }", |
| 1039 | "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.cap); }", |
| 1040 | "fn change(p: &mut *u8, q: *u8) { set *p = q; } fn run(q: *u8) { let mut s: *[u8] = &[]; change(&mut s.ptr, q); }", |
| 1041 | "fn run(s: &mut *[u8]) { set s.len = 100; }", |
| 1042 | "static DATA: [u8; 1] = [42]; fn run() -> u8 { let mut s = &DATA[..]; set s.len = 100; return s[99]; }", |
| 1043 | ]; |
| 1044 | for program in programs { |
| 1045 | let mut a = testResolver(); |
| 1046 | let result = try resolveProgramStr(&mut a, program); |
| 1047 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1048 | } |
| 1049 | try expectAnalyzeOk("unsafe fn run(s: *mut [u8]) { set s.len = 0; set s.cap = 0; }"); |
| 1050 | try expectAnalyzeOk("unsafe fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }"); |
| 1051 | try expectAnalyzeOk( |
| 1052 | "fn change(n: &mut u32) { set *n = 0; } unsafe fn run(s: *mut [u8]) { change(&mut s.len); }" |
| 1053 | ); |
| 1054 | try expectAnalyzeOk("fn run(s: *mut [u8]) { set s[0] = 1; }"); |
| 1055 | try expectAnalyzeOk("record R { len: u32 } fn run(r: &mut R) { set r.len = 1; }"); |
| 1056 | } |
| 1057 | |
| 1058 | /// Unsafe blocks permit operations within a safe function. |
| 1059 | @test unsafe fn testUnsafeBlocksAllowed() throws (testing::TestError) { |
| 1060 | try expectAnalyzeOk("fn run(p: *u8) -> *u8 { unsafe { return p + 1; } }"); |
| 1061 | try expectAnalyzeOk( |
| 1062 | "unsafe fn read(p: *unsafe u8) -> u8 { return *p; } fn run(p: *unsafe u8) -> u8 { unsafe { return read(p); } }" |
| 1063 | ); |
| 1064 | try expectAnalyzeOk("fn run(p: *u8) -> *[u8] { unsafe { { return @sliceOf(p, 1); } } }"); |
| 1065 | try expectAnalyzeOk("fn run(p: *u8) -> *u64 { unsafe { unsafe { return p as *u64; } } }"); |
| 1066 | try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { unsafe {} return p + 1; }"); |
| 1067 | } |
| 1068 | |
| 1069 | /// Unsafe permission ends at the closing brace and at function boundaries. |
| 1070 | @test unsafe fn testUnsafeBlockContextRestored() throws (testing::TestError) { |
| 1071 | let programs = &[ |
| 1072 | "fn run(p: *u8) -> *u8 { unsafe { let q = p + 1; } return p + 1; }", |
| 1073 | "fn run(p: *u8) -> *u8 { unsafe { unsafe {} } return p + 1; }", |
| 1074 | "unsafe fn first(p: *u8) -> *u8 { return p + 1; } fn second(p: *u8) -> *u8 { return p + 1; }", |
| 1075 | ]; |
| 1076 | for program in programs { |
| 1077 | let mut a = testResolver(); |
| 1078 | let result = try resolveProgramStr(&mut a, program); |
| 1079 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1080 | } |
| 1081 | let mut a = testResolver(); |
| 1082 | let result = try resolveProgramStr( |
| 1083 | &mut a, "unsafe fn act() {} fn run() { unsafe { act(); } act(); }" |
| 1084 | ); |
| 1085 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 1086 | } |
| 1087 | |
| 1088 | /// Resolution errors do not extend an unsafe block's permission. |
| 1089 | @test unsafe fn testUnsafeBlockErrorRestoresContext() throws (testing::TestError) { |
| 1090 | let mut a = testResolver(); |
| 1091 | let result = try resolveProgramStr( |
| 1092 | &mut a, "fn run(p: *u8) { unsafe { missing; } let q = p + 1; }" |
| 1093 | ); |
| 1094 | let mut found = false; |
| 1095 | for err in result.diagnostics.errors { |
| 1096 | if let case resolver::ErrorKind::UnsafeOperation = err.kind { |
| 1097 | set found = true; |
| 1098 | } |
| 1099 | } |
| 1100 | try testing::expect(found); |
| 1101 | } |
| 1102 | |
| 1103 | /// Unsafe blocks preserve reference lifetime checks. |
| 1104 | @test unsafe fn testUnsafeBlockPreservesReferences() throws (testing::TestError) { |
| 1105 | let mut a = testResolver(); |
| 1106 | let result = try resolveProgramStr( |
| 1107 | &mut a, "fn run() { let mut n: u32 = 1; let p = &n; unsafe { set n = 2; } }" |
| 1108 | ); |
| 1109 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("n")); |
| 1110 | } |
| 1111 | |
| 1112 | /// Slice pointer access requires an unsafe context for every slice class. |
| 1113 | @test unsafe fn testSlicePointerRequiresUnsafe() throws (testing::TestError) { |
| 1114 | let programs = &[ |
| 1115 | "fn run(s: *[u8]) -> *u8 { return s.ptr; }", |
| 1116 | "fn run(s: *mut [u8]) -> *mut u8 { return s.ptr; }", |
| 1117 | "fn run(s: &[u8]) -> u8 { return *s.ptr; }", |
| 1118 | "fn run(s: &mut [u8]) { set *s.ptr = 1; }", |
| 1119 | "fn run(s: &*[u8]) -> *u8 { return s.ptr; }", |
| 1120 | "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = &DATA[1..]; return *s.ptr; }", |
| 1121 | "fn run(s: *[u8]) -> u64 { return s.ptr as u64; }", |
| 1122 | ]; |
| 1123 | for program in programs { |
| 1124 | let mut a = testResolver(); |
| 1125 | let result = try resolveProgramStr(&mut a, program); |
| 1126 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1127 | } |
| 1128 | try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *u8 { return s.ptr; }"); |
| 1129 | try expectAnalyzeOk("fn run(s: *[u8]) -> u64 { unsafe { return s.ptr as u64; } }"); |
| 1130 | try expectAnalyzeOk("fn run(s: *[u8]) -> *u8 { return &s[0]; }"); |
| 1131 | try expectAnalyzeOk("fn run(s: *[u8]) -> u32 { return s.len + s.cap; }"); |
| 1132 | try expectAnalyzeOk("record R { ptr: u32 } fn run(r: R) -> u32 { return r.ptr; }"); |
| 1133 | } |
| 1134 | |
| 1135 | /// Unsafe statics require unsafe permission for reads, writes, and addresses. |
| 1136 | @test unsafe fn testUnsafeStaticAccessRejected() throws (testing::TestError) { |
| 1137 | let programs = &[ |
| 1138 | "unsafe static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }", |
| 1139 | "unsafe static VALUE: u32 = 7; fn run() { set VALUE = 8; }", |
| 1140 | "unsafe static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }", |
| 1141 | "unsafe static VALUE: u32 = 7; fn run() -> *mut u32 { return &mut VALUE; }", |
| 1142 | "unsafe static DATA: [u8; 1] = [42]; fn run() -> u8 { return DATA[0]; }", |
| 1143 | "unsafe static DATA: [u8; 1] = [42]; fn run() -> u32 { return DATA.len; }", |
| 1144 | "record R { value: u32 } unsafe static DATA: R = R { value: 7 }; fn run() -> u32 { return DATA.value; }", |
| 1145 | ]; |
| 1146 | for program in programs { |
| 1147 | let mut a = testResolver(); |
| 1148 | let result = try resolveProgramStr(&mut a, program); |
| 1149 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1150 | } |
| 1151 | } |
| 1152 | |
| 1153 | /// Unsafe blocks and functions can access unsafe statics. |
| 1154 | @test unsafe fn testUnsafeStaticAccessAllowed() throws (testing::TestError) { |
| 1155 | try expectAnalyzeOk( |
| 1156 | "unsafe static VALUE: u32 = 7; unsafe fn run() -> u32 { set VALUE = 8; return VALUE; }" |
| 1157 | ); |
| 1158 | try expectAnalyzeOk( |
| 1159 | "unsafe static VALUE: u32 = 7; fn run() -> u32 { unsafe { return VALUE; } }" |
| 1160 | ); |
| 1161 | try expectAnalyzeOk( |
| 1162 | "unsafe static VALUE: u32 = 7; unsafe fn run() -> *mut u32 { return &mut VALUE; }" |
| 1163 | ); |
| 1164 | try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }"); |
| 1165 | try expectAnalyzeOk( |
| 1166 | "constant BYTES: *[u8] = \"x\"; unsafe static DATA: *[u64] = BYTES as *[u64];" |
| 1167 | ); |
| 1168 | } |
| 1169 | |
| 1170 | /// Imports preserve the unsafe access requirement of a static. |
| 1171 | @test unsafe fn testUnsafeStaticImportsRejected() throws (testing::TestError) { |
| 1172 | let programs = &[ |
| 1173 | "use root::storage; fn run() -> u32 { return storage::VALUE; }", |
| 1174 | "use root::storage::*; fn run() -> u32 { return VALUE; }", |
| 1175 | ]; |
| 1176 | for program in programs { |
| 1177 | let mut a = testResolver(); |
| 1178 | let rootId = try registerModule( |
| 1179 | &mut super::MODULE_GRAPH, nil, "root", "export mod storage; mod app;" |
| 1180 | ); |
| 1181 | try registerModule( |
| 1182 | &mut super::MODULE_GRAPH, rootId, "storage", "export unsafe static VALUE: u32 = 7;" |
| 1183 | ); |
| 1184 | try registerModule(&mut super::MODULE_GRAPH, rootId, "app", program); |
| 1185 | let result = try resolveModuleTree(&mut a, rootId); |
| 1186 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1187 | } |
| 1188 | } |
| 1189 | |
| 1190 | /// An invalid unsafe static initializer does not grant permission to other initializers. |
| 1191 | @test unsafe fn testUnsafeStaticInitializerRestoresContext() throws (testing::TestError) { |
| 1192 | let mut a = testResolver(); |
| 1193 | let result = try resolveProgramStr( |
| 1194 | &mut a, "unsafe static BAD: u32 = true; static DATA: bool = undefined;" |
| 1195 | ); |
| 1196 | try expectError(&result); |
| 1197 | try testing::expect(not a.inUnsafeContext); |
| 1198 | |
| 1199 | let mut b = testResolver(); |
| 1200 | let next = try resolveProgramStr( |
| 1201 | &mut b, |
| 1202 | "unsafe static VALUE: u32 = 7; static DATA: bool = undefined;" |
| 1203 | ); |
| 1204 | try expectErrorKind(&next, resolver::ErrorKind::UnsafeOperation); |
| 1205 | } |
| 1206 | |
| 1207 | /// Uninitialized values require an explicit unsafe context in every value position. |
| 1208 | @test unsafe fn testUndefinedRequiresUnsafe() throws (testing::TestError) { |
| 1209 | let programs = &[ |
| 1210 | "fn run() { let n = undefined; }", |
| 1211 | "fn run() -> *u8 { return undefined; }", |
| 1212 | "fn take(p: *u8) {} fn run() { take(undefined); }", |
| 1213 | "fn run(p: *u8) { let mut q = p; set q = undefined; }", |
| 1214 | "fn run() { let pointers: [*u8; 1] = [undefined]; }", |
| 1215 | "fn run() { let pointers: [*u8; 2] = [undefined; 2]; }", |
| 1216 | "record R: Copy { p: *u8 } fn run() { let r = R { p: undefined }; }", |
| 1217 | "union U: Copy { Value { p: *u8 } } fn run() { let u = U::Value { p: undefined }; }", |
| 1218 | "static P: *u8 = undefined;", |
| 1219 | "constant P: *u8 = undefined;", |
| 1220 | "record R: Copy { p: *u8 } static VALUE: R = R { p: undefined };", |
| 1221 | ]; |
| 1222 | for program in programs { |
| 1223 | let mut a = testResolver(); |
| 1224 | let result = try resolveProgramStr(&mut a, program); |
| 1225 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1226 | } |
| 1227 | try expectAnalyzeOk("unsafe fn run() { let p: *u8 = undefined; }"); |
| 1228 | try expectAnalyzeOk( |
| 1229 | "fn run() -> u32 { unsafe { let mut n: u32 = undefined; set n = 7; return n; } }" |
| 1230 | ); |
| 1231 | try expectAnalyzeOk("unsafe static P: *u8 = undefined;"); |
| 1232 | try expectAnalyzeOk("record R: Copy { p: *u8 } unsafe static VALUE: R = R { p: undefined };"); |
| 1233 | try expectAnalyzeOk("fn run() { let data: [u8; 4] = [0; 4]; let pointer: ?*u8 = nil; }"); |
| 1234 | try expectAnalyzeOk("static DATA: [u8; 4] = [0; 4];"); |
| 1235 | } |
| 1236 | |
| 1237 | /// `undefined` needs no `unsafe` where the expected type is bit-valid. |
| 1238 | @test unsafe fn testUndefinedBitValidAccepted() throws (testing::TestError) { |
| 1239 | let programs = &[ |
| 1240 | // Integers, read before any assignment. |
| 1241 | "fn run() -> u8 { let x: u8 = undefined; return x; }", |
| 1242 | "fn run() -> u16 { let x: u16 = undefined; return x; }", |
| 1243 | "fn run() -> u32 { let mut x: u32 = undefined; return x; }", |
| 1244 | "fn run() -> u64 { let x: u64 = undefined; return x; }", |
| 1245 | "fn run() -> i8 { let x: i8 = undefined; return x; }", |
| 1246 | "fn run() -> i16 { let x: i16 = undefined; return x; }", |
| 1247 | "fn run() -> i32 { let x: i32 = undefined; return x; }", |
| 1248 | "fn run() -> i64 { let x: i64 = undefined; return x; }", |
| 1249 | // Arrays of integers and nested arrays. |
| 1250 | "fn run() -> u8 { let mut buf: [u8; 16] = undefined; set buf[0] = 1; return buf[15]; }", |
| 1251 | "fn run() -> u8 { let buf: [[u8; 4]; 4] = undefined; return buf[1][2]; }", |
| 1252 | "fn run() -> u32 { let buf: [u8; 0] = undefined; return 0; }", |
| 1253 | // Records of integers, ID records, and nested aggregates. |
| 1254 | "record BlockId(u32): Copy; fn run() -> u32 { let id: BlockId = undefined; return *id; }", |
| 1255 | "record BlockId(u32): Copy; fn run(c: bool) -> u32 { let mut id: BlockId = undefined; if c { set id = BlockId(1); } if c { return *id; } return 0; }", |
| 1256 | "record P: Copy { a: u32, b: u8 } fn run() -> u32 { let p: P = undefined; return p.a; }", |
| 1257 | "record P { a: u32, b: u32 } fn take(p: P) {} fn run() { let p: P = undefined; take(p); }", |
| 1258 | "record E: Copy { n: u32 } record B: Copy { items: [E; 4], len: u32 } fn run() -> u32 { let b: B = undefined; return b.items[2].n + b.len; }", |
| 1259 | "record E: Copy { n: u32 } fn run() -> u32 { let items: [E; 4] = undefined; return items[3].n; }", |
| 1260 | "record Empty: Copy {} fn run() { let e: Empty = undefined; }", |
| 1261 | // Record literal fields, array elements, and other value positions. |
| 1262 | "record R { buf: [u8; 4], len: u32 } fn run() -> u32 { let r = R { buf: undefined, len: 0 }; return r.len; }", |
| 1263 | "record R: Copy { n: u32 } fn run() -> u32 { let r = R { n: undefined }; return r.n; }", |
| 1264 | "union U: Copy { Value { n: u32 }, Empty } fn run() { let u = U::Value { n: undefined }; }", |
| 1265 | "record Token: Once { id: u32 } fn run() -> Token { return Token { id: undefined }; }", |
| 1266 | "fn run() -> u32 { let a: [u32; 2] = [undefined, 1]; return a[0]; }", |
| 1267 | "fn run() -> u32 { let a: [u32; 2] = [undefined; 2]; return a[0]; }", |
| 1268 | "fn take(n: u32) {} fn run() { take(undefined); }", |
| 1269 | "fn run() -> u32 { return undefined; }", |
| 1270 | "fn run() -> u32 { let mut n: u32 = 0; set n = undefined; return n; }", |
| 1271 | // Statics. |
| 1272 | "static DATA: [u8; 4] = undefined;", |
| 1273 | "record R: Copy { n: u32, buf: [u8; 4] } static VALUE: R = R { n: 1, buf: undefined };", |
| 1274 | ]; |
| 1275 | for program in programs { |
| 1276 | try expectAnalyzeOk(program); |
| 1277 | } |
| 1278 | } |
| 1279 | |
| 1280 | /// `undefined` with a type that has invalid bit patterns, or that is not plain |
| 1281 | /// data, is an unsafe operation in every position that is not a typed local. |
| 1282 | @test unsafe fn testUndefinedNotBitValidRequiresUnsafe() throws (testing::TestError) { |
| 1283 | let programs = &[ |
| 1284 | "fn run() -> bool { return undefined; }", |
| 1285 | "fn take(b: bool) {} fn run() { take(undefined); }", |
| 1286 | "union K { A, B } fn run() -> K { return undefined; }", |
| 1287 | "union K { A { n: u32 }, B } fn run() -> K { return undefined; }", |
| 1288 | "fn run() -> *u8 { return undefined; }", |
| 1289 | "fn run() -> *mut u8 { return undefined; }", |
| 1290 | "fn run() -> *unsafe u8 { return undefined; }", |
| 1291 | "fn run() -> *[u8] { return undefined; }", |
| 1292 | "fn run() -> ?u32 { return undefined; }", |
| 1293 | "fn run() -> fn() { return undefined; }", |
| 1294 | "static F: fn(u32) -> u32 = undefined;", |
| 1295 | "fn take(s: [*[u8]; 2]) {} fn run() { take(undefined); }", |
| 1296 | "static B: [bool; 2] = undefined;", |
| 1297 | "record R: Copy { s: *[u8], n: u32 } fn take(r: R) {} fn run() { take(undefined); }", |
| 1298 | "record R: Copy { p: *u8 } record Outer: Copy { r: R } fn take(r: Outer) {} fn run() { take(undefined); }", |
| 1299 | "record R: Copy { b: bool } fn take(r: R) {} fn run() { take(undefined); }", |
| 1300 | "record R: Copy { b: bool } fn take(r: [R; 2]) {} fn run() { take(undefined); }", |
| 1301 | "record R { buf: [u8; 4], flag: bool } fn run() -> u32 { let r = R { buf: [0; 4], flag: undefined }; return 0; }", |
| 1302 | "record Token: Once { id: u32 } fn run() -> Token { return undefined; }", |
| 1303 | "record Token: Once { id: u32 } record Pair { t: Token } fn run() -> Pair { return undefined; }", |
| 1304 | "record Token: Once { id: u32 } static T: Token = undefined;", |
| 1305 | ]; |
| 1306 | for program in programs { |
| 1307 | let mut a = testResolver(); |
| 1308 | let result = try resolveProgramStr(&mut a, program); |
| 1309 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1310 | } |
| 1311 | } |
| 1312 | |
| 1313 | /// A typed local of a type that is not bit-valid is accepted and tracked. |
| 1314 | @test unsafe fn testUndefinedNotBitValidLocalTracked() throws (testing::TestError) { |
| 1315 | let programs = &[ |
| 1316 | "fn run() -> bool { let x: bool = undefined; return x; }", |
| 1317 | "union K { A, B } fn run() -> K { let x: K = undefined; return x; }", |
| 1318 | "fn run() -> *u8 { let x: *u8 = undefined; return x; }", |
| 1319 | "fn run() -> *[u8] { let x: *[u8] = undefined; return x; }", |
| 1320 | "fn run() -> ?u32 { let x: ?u32 = undefined; return x; }", |
| 1321 | "fn run() -> [*[u8]; 2] { let x: [*[u8]; 2] = undefined; return x; }", |
| 1322 | "record R: Copy { s: *[u8], n: u32 } fn run() -> R { let x: R = undefined; return x; }", |
| 1323 | "record R: Copy { b: bool } fn run() -> [R; 2] { let x: [R; 2] = undefined; return x; }", |
| 1324 | "fn run() -> fn() { let x: fn() = undefined; return x; }", |
| 1325 | ]; |
| 1326 | for program in programs { |
| 1327 | try expectUninitialized(program); |
| 1328 | } |
| 1329 | try expectAnalyzeOk( |
| 1330 | "fn run() -> bool { let mut x: bool = undefined; set x = true; return x; }" |
| 1331 | ); |
| 1332 | } |
| 1333 | |
| 1334 | /// A linear type cannot be initialized with `undefined`, even when its fields are bit-valid. |
| 1335 | @test unsafe fn testUndefinedLinearLocalRejected() throws (testing::TestError) { |
| 1336 | let programs = &[ |
| 1337 | "record Token: Once { id: u32 } fn run() { let t: Token = undefined; }", |
| 1338 | "record Token: Once { id: u32 } fn run() { let mut t: Token = undefined; }", |
| 1339 | "record Token: Once { id: u32 } record Pair { t: Token } fn run() { let p: Pair = undefined; }", |
| 1340 | "record Token: Once { id: u32 } fn run() { let a: [Token; 2] = undefined; }", |
| 1341 | ]; |
| 1342 | for program in programs { |
| 1343 | let mut a = testResolver(); |
| 1344 | let result = try resolveProgramStr(&mut a, program); |
| 1345 | try expectErrorKind(&result, resolver::ErrorKind::LinearUndefined); |
| 1346 | } |
| 1347 | } |
| 1348 | |
| 1349 | /// Unsafe initialization does not grant permission to subsequent safe expressions. |
| 1350 | @test unsafe fn testUndefinedContextRestored() throws (testing::TestError) { |
| 1351 | let mut a = testResolver(); |
| 1352 | let result = try resolveProgramStr( |
| 1353 | &mut a, |
| 1354 | "fn run(p: *u8) { unsafe { let q: *u8 = undefined; } let mut r = p; set r = undefined; }" |
| 1355 | ); |
| 1356 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1357 | let mut b = testResolver(); |
| 1358 | let next = try resolveProgramStr( |
| 1359 | &mut b, "unsafe static P: *u8 = undefined; static Q: *u8 = undefined;" |
| 1360 | ); |
| 1361 | try expectErrorKind(&next, resolver::ErrorKind::UnsafeOperation); |
| 1362 | } |
| 1363 | |
| 1364 | /// Unsafe declarations may compose unsafe operations and calls. |
| 1365 | @test unsafe fn testUnsafePointerOperationsAllowed() throws (testing::TestError) { |
| 1366 | let program = |
| 1367 | "record Marker: Once {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }"; |
| 1368 | try expectAnalyzeOk(program); |
| 1369 | } |
| 1370 | |
| 1371 | /// Unsafe code may drop a checked reference to an unsafe pointer. |
| 1372 | @test unsafe fn testUnsafePointerFromReference() throws (testing::TestError) { |
| 1373 | let program = |
| 1374 | "record Marker: Once {} unsafe fn store(pointer: *unsafe mut u32) { set *pointer = 42; } unsafe fn run() { let mut value: u32 = 0; store(&mut value as *unsafe mut u32); }"; |
| 1375 | try expectAnalyzeOk(program); |
| 1376 | } |
| 1377 | |
| 1378 | /// Dropping a reference to an unsafe pointer cannot add mutability. |
| 1379 | @test unsafe fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) { |
| 1380 | let mut a = testResolver(); |
| 1381 | let program = "record Marker: Once {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }"; |
| 1382 | let result = try resolveProgramStr(&mut a, program); |
| 1383 | let err = try expectError(&result); |
| 1384 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind else throw testing::TestError::Failed; |
| 1385 | } |
| 1386 | |
| 1387 | /// Recursive cast validation cannot hide a checked-to-unsafe transition. |
| 1388 | @test unsafe fn testNestedUnsafePointerCastRejected() throws (testing::TestError) { |
| 1389 | let mut a = testResolver(); |
| 1390 | let program = "record Marker: Once {} fn run(value: **u32) { value as **unsafe u32; }"; |
| 1391 | let result = try resolveProgramStr(&mut a, program); |
| 1392 | let err = try expectError(&result); |
| 1393 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind else throw testing::TestError::Failed; |
| 1394 | } |
| 1395 | |
| 1396 | /// Unsafe code may drop a checked slice reference to an unsafe slice. |
| 1397 | @test unsafe fn testUnsafeSliceFromReference() throws (testing::TestError) { |
| 1398 | let program = |
| 1399 | "record Marker: Once {} unsafe fn run(values: &[u32]) { let raw: *unsafe [u32] = values as *unsafe [u32]; }"; |
| 1400 | try expectAnalyzeOk(program); |
| 1401 | } |
| 1402 | |
| 1403 | /// Slice casts cannot add mutability. |
| 1404 | @test unsafe fn testSliceCastCannotAddMutability() throws (testing::TestError) { |
| 1405 | let mut a = testResolver(); |
| 1406 | let program = "record Marker: Once {} fn run(values: &[u32]) { values as &mut [u32]; }"; |
| 1407 | let result = try resolveProgramStr(&mut a, program); |
| 1408 | let err = try expectError(&result); |
| 1409 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind else throw testing::TestError::Failed; |
| 1410 | } |
| 1411 | |
| 1412 | /// Mutable unsafe receivers do not create checked exclusive loans. |
| 1413 | @test unsafe fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) { |
| 1414 | let program = |
| 1415 | "record Marker: Once {} record Value { number: u32 } unsafe fn (value: *unsafe mut Value) update(other: *unsafe mut Value) {} unsafe fn run(value: *unsafe mut Value) { value.update(value); }"; |
| 1416 | try expectAnalyzeOk(program); |
| 1417 | } |
| 1418 | |
| 1419 | /// Unsafe instance-method attributes enable unsafe operations in the body. |
| 1420 | @test unsafe fn testUnsafeInstanceMethodBody() throws (testing::TestError) { |
| 1421 | let program = |
| 1422 | "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (*unsafe Read) get() -> u32; } instance Read for Value { unsafe fn (value: *unsafe Value) get() -> u32 { return value.number; } }"; |
| 1423 | try expectAnalyzeOk(program); |
| 1424 | } |
| 1425 | |
| 1426 | /// Unsafe instance methods cannot implement safe trait contracts. |
| 1427 | @test unsafe fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) { |
| 1428 | let mut a = testResolver(); |
| 1429 | let program = |
| 1430 | "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }"; |
| 1431 | let result = try resolveProgramStr(&mut a, program); |
| 1432 | try expectErrorKind(&result, resolver::ErrorKind::TraitMethodSafetyMismatch); |
| 1433 | } |
| 1434 | |
| 1435 | /// Unsafe trait methods retain their call-site requirement through dispatch. |
| 1436 | @test unsafe fn testUnsafeTraitMethodCallRejected() throws (testing::TestError) { |
| 1437 | let mut a = testResolver(); |
| 1438 | let program = |
| 1439 | "record Marker: Once {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }"; |
| 1440 | let result = try resolveProgramStr(&mut a, program); |
| 1441 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 1442 | } |
| 1443 | |
| 1444 | /// An unsafe callback retains its requirement at an indirect call. |
| 1445 | @test unsafe fn testUnsafeCallbackCallRejected() throws (testing::TestError) { |
| 1446 | let mut a = testResolver(); |
| 1447 | let result = try resolveProgramStr( |
| 1448 | &mut a, "fn run(callback: unsafe fn() -> u32) -> u32 { return callback(); }" |
| 1449 | ); |
| 1450 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 1451 | } |
| 1452 | |
| 1453 | /// An unsafe function cannot enter a safe callback slot. |
| 1454 | @test unsafe fn testUnsafeCallbackAssignmentRejected() throws (testing::TestError) { |
| 1455 | let mut a = testResolver(); |
| 1456 | let result = try resolveProgramStr( |
| 1457 | &mut a, |
| 1458 | "unsafe fn load() -> u32 { return 1; } fn run() { let callback: fn() -> u32 = load; }" |
| 1459 | ); |
| 1460 | let err = try expectError(&result); |
| 1461 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 1462 | } |
| 1463 | |
| 1464 | /// A safe function can enter an unsafe callback slot. |
| 1465 | @test unsafe fn testSafeCallbackIntoUnsafeSlot() throws (testing::TestError) { |
| 1466 | try expectAnalyzeOk( |
| 1467 | "fn load() -> u32 { return 1; } unsafe fn run() -> u32 { let callback: unsafe fn() -> u32 = load; return callback(); }" |
| 1468 | ); |
| 1469 | } |
| 1470 | |
| 1471 | /// Borrowed callback storage must preserve its function safety type. |
| 1472 | @test unsafe fn testBorrowedCallbackSafetyInvariant() throws (testing::TestError) { |
| 1473 | let mut a = testResolver(); |
| 1474 | let result = try resolveProgramStr( |
| 1475 | &mut a, |
| 1476 | "fn replace(slot: &mut unsafe fn()) {} fn load() {} fn run() { let mut callback: fn() = load; replace(&mut callback); }" |
| 1477 | ); |
| 1478 | let err = try expectError(&result); |
| 1479 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed; |
| 1480 | } |
| 1481 | |
| 1482 | /// Referenced storage must preserve its exact element type in every context. |
| 1483 | @test unsafe fn testPointerStorageCoercionsRejected() throws (testing::TestError) { |
| 1484 | let programs = &[ |
| 1485 | "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; fn run() { let mut p = &DATA; replace(&mut p); }", |
| 1486 | "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; unsafe fn run() { let mut p = &DATA; replace(&mut p); }", |
| 1487 | "fn replace(p: &mut ?*u8) { set *p = nil; } static DATA: u8 = 7; fn run() { let mut p = &DATA; unsafe { replace(&mut p); } }", |
| 1488 | "fn take(p: *?u32) {} fn run(p: *u32) { take(p); }", |
| 1489 | "unsafe fn take(p: *unsafe mut ?*u8) {} unsafe fn run(p: *unsafe mut *u8) { take(p); }", |
| 1490 | "fn take(p: *[?*u8]) {} fn run(p: *[*u8]) { take(p); }", |
| 1491 | "unsafe fn take(p: *mut [?*u8]) {} unsafe fn run(p: *mut [*u8]) { take(p); }", |
| 1492 | "fn take(p: &mut **u8) {} fn run(p: &mut *mut *u8) { take(p); }", |
| 1493 | ]; |
| 1494 | for program in programs { |
| 1495 | let mut a = testResolver(); |
| 1496 | let result = try resolveProgramStr(&mut a, program); |
| 1497 | let err = try expectError(&result); |
| 1498 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind |
| 1499 | else throw testing::TestError::Failed; |
| 1500 | } |
| 1501 | try expectAnalyzeOk( |
| 1502 | "fn take(p: &mut ?*u8) {} fn run() { let mut p: ?*u8 = nil; take(&mut p); }" |
| 1503 | ); |
| 1504 | try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p; }"); |
| 1505 | try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p; }"); |
| 1506 | } |
| 1507 | |
| 1508 | /// Casts cannot add or remove optionality in referenced storage. |
| 1509 | @test unsafe fn testPointerOptionalStorageCastsRejected() throws (testing::TestError) { |
| 1510 | let programs = &[ |
| 1511 | "fn run(p: **u8) { p as *?*u8; }", |
| 1512 | "unsafe fn run(p: *mut *u8) { p as *mut ?*u8; }", |
| 1513 | "fn run(p: *mut *u8) { unsafe { p as *mut ?*u8; } }", |
| 1514 | "unsafe fn run(p: *mut ?*u8) { p as *mut *u8; }", |
| 1515 | "unsafe fn run(p: *unsafe mut *u8) { p as *unsafe mut ?*u8; }", |
| 1516 | "unsafe fn run(p: *mut [*u8]) { p as *mut [?*u8]; }", |
| 1517 | ]; |
| 1518 | for program in programs { |
| 1519 | let mut a = testResolver(); |
| 1520 | let result = try resolveProgramStr(&mut a, program); |
| 1521 | let err = try expectError(&result); |
| 1522 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind |
| 1523 | else throw testing::TestError::Failed; |
| 1524 | } |
| 1525 | } |
| 1526 | |
| 1527 | /// Pattern references prevent replacement of their source in every context. |
| 1528 | @test unsafe fn testPatternLoanMutationRejected() throws (testing::TestError) { |
| 1529 | let programs = &[ |
| 1530 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { set u = U::B(1); *p; } else => {} } }", |
| 1531 | "union U: Copy { A(u64), B(u64) } unsafe fn run() { let mut u = U::A(7); match &u { case U::A(p) => { set u = U::B(1); *p; } else => {} } }", |
| 1532 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &mut u { case U::A(p) => { unsafe { set u = U::B(1); } *p; } else => {} } }", |
| 1533 | "union U: Copy { A(u64), B(u64) } fn change(u: &mut U) { set *u = U::B(1); } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { change(&mut u); *p; } else => {} } }", |
| 1534 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); if let case U::A(p) = &u { set u = U::B(1); *p; } }", |
| 1535 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); while let case U::A(p) = &u { set u = U::B(1); *p; } }", |
| 1536 | "union U: Copy { A(u64), B(u64) } fn run(u: *mut U) { match u { case U::A(p) => { let moved = u; *p; } else => {} } }", |
| 1537 | ]; |
| 1538 | for program in programs { |
| 1539 | let mut a = testResolver(); |
| 1540 | let result = try resolveProgramStr(&mut a, program); |
| 1541 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("u")); |
| 1542 | } |
| 1543 | } |
| 1544 | |
| 1545 | /// Pattern loans end at their scope and permit writes through mutable payload references. |
| 1546 | @test unsafe fn testPatternLoanScopeAllowed() throws (testing::TestError) { |
| 1547 | try expectAnalyzeOk( |
| 1548 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &u { case U::A(p) => { *p; } else => {} } set u = U::B(1); }" |
| 1549 | ); |
| 1550 | try expectAnalyzeOk( |
| 1551 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); match &mut u { case U::A(p) => { set *p = 8; } else => {} } set u = U::B(1); }" |
| 1552 | ); |
| 1553 | try expectAnalyzeOk( |
| 1554 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = U::A(7); if let case U::A(p) = &u { *p; } else { set u = U::A(1); } set u = U::B(1); }" |
| 1555 | ); |
| 1556 | } |
| 1557 | |
| 1558 | /// Replacing a borrowed pointer payload cannot forge an address, because a union that mixes |
| 1559 | /// pointer and plain payloads binds its payloads by value. |
| 1560 | @test unsafe fn testBorrowedPointerPayloadReplacementRejected() throws (testing::TestError) { |
| 1561 | let programs = &[ |
| 1562 | "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }", |
| 1563 | "static DATA: u8 = 7; union U: Copy { A(*u8), B(u64) } unsafe fn run() -> u8 { let mut u = U::A(&DATA); match &u { case U::A(p) => { set u = U::B(1); return **p; } else => return 0, } }", |
| 1564 | ]; |
| 1565 | for program in programs { |
| 1566 | let mut a = testResolver(); |
| 1567 | let result = try resolveProgramStr(&mut a, program); |
| 1568 | try expectErrorKind(&result, resolver::ErrorKind::MixedUnionByReference); |
| 1569 | } |
| 1570 | } |
| 1571 | |
| 1572 | /// Guards, nested patterns, and unsafe calls must preserve pattern source storage. |
| 1573 | @test unsafe fn testPatternLoanIndirectMutationRejected() throws (testing::TestError) { |
| 1574 | let programs = &[ |
| 1575 | "fn run() { let mut u: ?u64 = 7; match &u { p => { set u = nil; *p; } else => {} } }", |
| 1576 | "union U: Copy { A(u64), B(u64) } fn change(u: &mut U) -> bool { set *u = U::B(1); return true; } fn run() { let mut u = U::A(7); match &u { case U::A(p) if change(&mut u) => { *p; } else => {} } }", |
| 1577 | "union U: Copy { A(u64), B(u64) } unsafe fn change(u: *unsafe mut U) { set *u = U::B(1); } unsafe fn run(u: *unsafe mut U) { match u { case U::A(p) => { change(u); *p; } else => {} } }", |
| 1578 | "union U: Copy { A(u64), B(u64) } record R: Copy { value: U } fn run() { let mut u = R { value: U::A(7) }; match &u.value { case U::A(p) => { set u.value = U::B(1); *p; } else => {} } }", |
| 1579 | "union U: Copy { A(u64), B(u64) } fn run() { let mut u = [U::A(7)]; match &u[0] { case U::A(p) => { set u[0] = U::B(1); *p; } else => {} } }", |
| 1580 | "union U: Copy { A(u64), B(u64) } unsafe fn (u: *unsafe mut U) change() { set *u = U::B(1); } unsafe fn run(u: *unsafe mut U) { match u { case U::A(p) => { u.change(); *p; } else => {} } }", |
| 1581 | ]; |
| 1582 | for program in programs { |
| 1583 | let mut a = testResolver(); |
| 1584 | let result = try resolveProgramStr(&mut a, program); |
| 1585 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("u")); |
| 1586 | } |
| 1587 | } |
| 1588 | |
| 1589 | /// Binding mutability does not permit writes through immutable pointers. |
| 1590 | @test unsafe fn testMutableBindingImmutableTargetRejected() throws (testing::TestError) { |
| 1591 | let programs = &[ |
| 1592 | "record R: Copy { n: u8 } fn run(input: *R) { let mut p = input; set p.n = 1; }", |
| 1593 | "record R: Copy { n: u8 } fn run(input: *R) { let mut p = input; let q = &mut p.n; }", |
| 1594 | "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; set p[0] = 1; }", |
| 1595 | "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; set p[..] = 1; }", |
| 1596 | "static DATA: [u8; 1] = [0]; fn run() { let mut p = &DATA; let q = &mut p[0]; }", |
| 1597 | "record R: Copy { n: u8 } fn (r: &mut R) change() { set r.n = 1; } fn run(input: *R) { let mut p = input; p.change(); }", |
| 1598 | ]; |
| 1599 | for program in programs { |
| 1600 | let mut a = testResolver(); |
| 1601 | let result = try resolveProgramStr(&mut a, program); |
| 1602 | try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 1603 | } |
| 1604 | // The binding itself is still immutable. |
| 1605 | let mut a = testResolver(); |
| 1606 | let result = try resolveProgramStr(&mut a, "fn run(p: *mut u8, q: *mut u8) { set p = q; }"); |
| 1607 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding); |
| 1608 | } |
| 1609 | |
| 1610 | /// Mutable targets support access through fixed and mutable pointer bindings. |
| 1611 | @test unsafe fn testMutablePointerTargetsAllowed() throws (testing::TestError) { |
| 1612 | try expectAnalyzeOk( |
| 1613 | "record R: Copy { n: u8 } fn (r: &mut R) change() { set r.n = 2; } fn run(p: *mut R) { set p.n = 1; p.change(); let q = &mut p.n; set *q = 3; }" |
| 1614 | ); |
| 1615 | try expectAnalyzeOk( |
| 1616 | "static DATA: [u8; 2] = [0, 0]; unsafe fn run() { let p = &mut DATA; set p[0] = 1; set p[..] = 2; let q = &mut p[0]; set *q = 3; }" |
| 1617 | ); |
| 1618 | try expectAnalyzeOk("fn run(first: *u8, second: *u8) { let mut p = first; set p = second; }"); |
| 1619 | } |
| 1620 | |
| 1621 | /// Pattern access through raw pointers requires an unsafe context. |
| 1622 | @test unsafe fn testRawPointerPatternRejected() throws (testing::TestError) { |
| 1623 | let programs = &[ |
| 1624 | "union U: Copy { A(u8), B } fn run(p: *unsafe U) { match p { case U::A(n) => { *n; } else => {} } }", |
| 1625 | "union U: Copy { A(u8), B } fn run(p: *unsafe U) { if let case U::A(n) = p { *n; } }", |
| 1626 | "union U: Copy { A(u8), B } fn run(p: *unsafe U) { while let case U::A(n) = p { *n; break; } }", |
| 1627 | "record R: Copy { n: u8 } fn run(p: *unsafe R) { let case R { n } = p else return; }", |
| 1628 | ]; |
| 1629 | for program in programs { |
| 1630 | let mut a = testResolver(); |
| 1631 | let result = try resolveProgramStr(&mut a, program); |
| 1632 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 1633 | } |
| 1634 | } |
| 1635 | |
| 1636 | /// Unsafe contexts permit pattern access through raw pointers. |
| 1637 | @test unsafe fn testRawPointerPatternsAllowed() throws (testing::TestError) { |
| 1638 | try expectAnalyzeOk( |
| 1639 | "union U: Copy { A(u8), B } unsafe fn run(p: *unsafe U) { match p { case U::A(n) => { *n; } else => {} } if let case U::A(n) = p { *n; } while let case U::A(n) = p { *n; break; } }" |
| 1640 | ); |
| 1641 | try expectAnalyzeOk( |
| 1642 | "record R: Copy { n: u8 } unsafe fn run(p: *unsafe R) { let case R { n } = p else return; }" |
| 1643 | ); |
| 1644 | } |
| 1645 | |
| 1646 | /// A record with the layout of the former allocator handle is not an allocator, whatever its shape. |
| 1647 | @test unsafe fn testSliceAppendRecordAllocatorRejected() throws (testing::TestError) { |
| 1648 | let programs = &[ |
| 1649 | "fn run(owned: *mut [u8]) { let mut s = owned; s.append(1, 0); }", |
| 1650 | "record A { ctx: *mut opaque, func: fn(*mut opaque, u32, u32) -> *mut opaque } fn run(owned: *mut [u8], a: A) { let mut s = owned; s.append(1, a); }", |
| 1651 | "record A { func: u64, ctx: u64 } fn run(owned: *mut [u8], a: A) { let mut s = owned; s.append(1, a); }", |
| 1652 | "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(owned: *mut [u8], a: A) { let mut s = owned; try! s.append(1, a); }", |
| 1653 | "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(owned: *mut [u8], a: A) { let mut s = owned; try! s.reserve(1, a); }", |
| 1654 | "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(owned: *mut [u8], a: A) { let mut s = owned; try! s.resize(1, 0, a); }", |
| 1655 | "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(owned: *mut [u8], src: &[u8], a: A) { let mut s = owned; try! s.extend(src, a); }", |
| 1656 | "union E: Copy { Exhausted } record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *unsafe mut opaque } fn run(owned: *mut [u8], a: A) { let mut s = owned; try! s.append(1, a); }", |
| 1657 | "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(owned: *mut [u8], a: &A) { let mut s = owned; try! s.append(1, a); }", |
| 1658 | ]; |
| 1659 | for program in programs { |
| 1660 | let mut a = testResolver(); |
| 1661 | let result = try resolveProgramStr(&mut a, program); |
| 1662 | try expectErrorKind(&result, resolver::ErrorKind::InvalidSliceAllocator); |
| 1663 | } |
| 1664 | } |
| 1665 | |
| 1666 | /// A live pattern reference protects its payload from writes through copied pointers. |
| 1667 | @test unsafe fn testPatternPayloadPointerAliasesRejected() throws (testing::TestError) { |
| 1668 | let programs = &[ |
| 1669 | "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; match p { case U::A(n) => { set *q = U::B; *n; } else => {} } }", |
| 1670 | "union U: Copy { A(*u8), B(u64) } fn run(p: *mut U) -> u8 { let q = p; match p { case U::A(n) => { set *q = U::B(1); return **n; } else => return 0, } }", |
| 1671 | "union U: Copy { A(u8), B } fn change(p: &mut U) { set *p = U::B; } fn run(p: *mut U) { let q = p; if let case U::A(n) = p { change(q); *n; } }", |
| 1672 | "union U: Copy { A(u8), B } fn run(p: *mut U) { let q = p; let r = q; while let case U::A(n) = p { set *r = U::B; *n; break; } }", |
| 1673 | ]; |
| 1674 | for program in programs { |
| 1675 | let mut a = testResolver(); |
| 1676 | let result = try resolveProgramStr(&mut a, program); |
| 1677 | try expectError(&result); |
| 1678 | } |
| 1679 | } |
| 1680 | |
| 1681 | /// Every access to a moved safe mutable pointer is rejected. |
| 1682 | @test unsafe fn testMutablePointerMovesRejected() throws (testing::TestError) { |
| 1683 | let programs = &[ |
| 1684 | "fn run(p: *mut u8) { let q = p; *p; }", |
| 1685 | "fn run(p: *mut u8) { let q = p; set *p = 1; }", |
| 1686 | "fn run(p: *mut u8) { let q = p; let r = &*p; }", |
| 1687 | "fn read(p: &u8) {} fn run(p: *mut u8) { let q = p; read(p); }", |
| 1688 | "fn run(p: &mut u8) { let q = p; *p; }", |
| 1689 | "fn run(p: *mut [u8]) { let q = p; p.len; }", |
| 1690 | "fn run(p: &mut [u8]) { let q = p; p[0]; }", |
| 1691 | "record R { value: u8 } fn run(p: *mut R) { let q = p; p.value; }", |
| 1692 | "trait T { fn (&T) read(); } fn run(p: *mut opaque T) { let q = p; p.read(); }", |
| 1693 | "fn run(p: *mut u8, flag: bool) { if flag { let q = p; } *p; }", |
| 1694 | "fn run(p: *mut u8) { loop { let q = p; } }", |
| 1695 | ]; |
| 1696 | for program in programs { |
| 1697 | let mut a = testResolver(); |
| 1698 | let result = try resolveProgramStr(&mut a, program); |
| 1699 | try expectError(&result); |
| 1700 | } |
| 1701 | } |
| 1702 | |
| 1703 | /// Copy composites cannot contain safe mutable owners or their containers. |
| 1704 | @test unsafe fn testCopyMutablePointerFieldsRejected() throws (testing::TestError) { |
| 1705 | let programs = &[ |
| 1706 | "record R: Copy { p: *mut u8 }", |
| 1707 | "union U: Copy { A(*mut u8), B }", |
| 1708 | "record R: Copy { p: ?*mut u8 }", |
| 1709 | "record R: Copy { p: [*mut u8; 2] }", |
| 1710 | "record R: Copy { p: *mut [u8] }", |
| 1711 | "trait T {} record R: Copy { p: *mut opaque T }", |
| 1712 | "record Inner { p: *mut u8 } record Outer: Copy { inner: Inner }", |
| 1713 | ]; |
| 1714 | for program in programs { |
| 1715 | let mut a = testResolver(); |
| 1716 | let result = try resolveProgramStr(&mut a, program); |
| 1717 | try expectErrorKind(&result, resolver::ErrorKind::CopyContainsNonCopy); |
| 1718 | } |
| 1719 | } |
| 1720 | |
| 1721 | /// Moves transfer safe mutable pointers, and calls can borrow them temporarily. |
| 1722 | @test unsafe fn testMutablePointerMovesAllowed() throws (testing::TestError) { |
| 1723 | try expectAnalyzeOk("fn run(p: *mut u8) -> u8 { let q = p; set *q = 1; return *q; }"); |
| 1724 | try expectAnalyzeOk( |
| 1725 | "fn setValue(p: &mut u8) { set *p = 1; } fn run(p: *mut u8) { setValue(p); setValue(p); *p; }" |
| 1726 | ); |
| 1727 | try expectAnalyzeOk("fn run(p: *u8) { let q = p; *p; *q; }"); |
| 1728 | try expectAnalyzeOk( |
| 1729 | "fn run(p: *mut u8, q: *mut u8) { unsafe { p == q; p as u64; } set *p = 1; set *q = 2; }" |
| 1730 | ); |
| 1731 | try expectAnalyzeOk( |
| 1732 | "record R: Copy { p: *unsafe mut u8 } unsafe fn run(p: *unsafe mut u8) { let q = p; set *p = 1; set *q = 2; }" |
| 1733 | ); |
| 1734 | try expectAnalyzeOk( |
| 1735 | "record R: Copy { p: *unsafe mut [u8] } unsafe fn run(p: *unsafe mut [u8]) { let q = p; set p[0] = 1; set q[0] = 2; }" |
| 1736 | ); |
| 1737 | } |
| 1738 | |
| 1739 | /// Local analysis state does not change function signature identity. |
| 1740 | @test unsafe fn testImmutableFunctionSignatures() throws (testing::TestError) { |
| 1741 | let mut res = testResolver(); |
| 1742 | let result = try resolveProgramStr( |
| 1743 | &mut res, |
| 1744 | "fn first(x: u8) -> u32 { return 0; } fn equivalent(y: u8) -> u32 { let a: u32 = 1; return a; } fn throwing(x: u8) -> u32 throws (u8) { throw x; } unsafe fn unsafeCall(x: u8) -> u32 { return 0; }" |
| 1745 | ); |
| 1746 | try expectNoErrors(&result); |
| 1747 | try expectImmutableFunctionSignatures(&res, result.root); |
| 1748 | } |
| 1749 | |
| 1750 | /// A diagnostic snapshot keeps its contents when the resolver buffer changes. |
| 1751 | @test unsafe fn testDiagnosticSnapshotOwnsItsErrors() throws (testing::TestError) { |
| 1752 | let mut res = testResolver(); |
| 1753 | let result = try resolveProgramStr(&mut res, "fn run() { missing; }"); |
| 1754 | let snapshot = result.diagnostics; |
| 1755 | let original = resolver::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed; |
| 1756 | set res.errors.entries[0] = resolver::Error { |
| 1757 | kind: resolver::ErrorKind::Internal, node: nil, moduleId: 0 |
| 1758 | }; |
| 1759 | let later = resolver::diagnostics(&mut res); |
| 1760 | try testing::expect(snapshot.errors.len == 1); |
| 1761 | try testing::expect(later.errors.len == 1); |
| 1762 | let first = resolver::errorAt(snapshot.errors, 0) else throw testing::TestError::Failed; |
| 1763 | try testing::expect(first.kind == original.kind); |
| 1764 | try testing::expect(later.errors[0].kind == resolver::ErrorKind::Internal); |
| 1765 | try testing::expect(resolver::errorAt(snapshot.errors, 1) == nil); |
| 1766 | } |
| 1767 | |
| 1768 | /// Prefixes, equal fields, and uncertain element locations must conflict. |
| 1769 | @test unsafe fn testOverlappingFieldBorrows() throws (testing::TestError) { |
| 1770 | let programs = &[ |
| 1771 | "record R: Copy { a: u32, b: u32 } fn take(a: &mut u32, b: &u32) {} fn run(r: &mut R) { take(&mut r.a, &r.a); }", |
| 1772 | "record R: Copy { a: u32, b: u32 } fn take(a: &mut R, b: &u32) {} fn run(r: &mut R) { take(r, &r.b); }", |
| 1773 | "record R: Copy { a: [u8; 2], b: [u8; 2] } fn take(a: &mut u8, b: &u8) {} fn run(r: &mut R) { take(&mut r.a[0], &r.a[1]); }", |
| 1774 | "record R: Copy { a: u32, b: u32 } fn take(a: &mut u32, b: u32) {} fn run(r: &mut R) { take(&mut r.a, r.a); }", |
| 1775 | ]; |
| 1776 | for program in programs { |
| 1777 | let mut a = testResolver(); |
| 1778 | let result = try resolveProgramStr(&mut a, program); |
| 1779 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("r")); |
| 1780 | } |
| 1781 | } |
| 1782 | |
| 1783 | /// Local loans exclude writes, competing references, and source reads. |
| 1784 | @test unsafe fn testLocalReferenceConflicts() throws (testing::TestError) { |
| 1785 | let programs = &[ |
| 1786 | "fn run() { let mut n: u32 = 4; let p = &n; set n = 1; }", |
| 1787 | "fn run() { let mut n: u32 = 4; let p = &mut n; n; }", |
| 1788 | "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &n; }", |
| 1789 | "fn run() { let mut n: u32 = 4; let p = &n; let q = &mut n; }", |
| 1790 | "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &mut *p; set *p = 1; }", |
| 1791 | "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &*p; set *p = 1; }", |
| 1792 | "fn take(p: &mut u32) {} fn run() { let mut n: u32 = 4; let p = &n; take(&mut n); }", |
| 1793 | "fn run() { let mut n: u32 = 4; let p = &n; unsafe { set n = 1; } }", |
| 1794 | "fn run() { let mut n: u32 = 4; let p = &mut n; let q = &*p; let moved = p; }", |
| 1795 | ]; |
| 1796 | for program in programs { |
| 1797 | let mut a = testResolver(); |
| 1798 | let result = try resolveProgramStr(&mut a, program); |
| 1799 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("n")); |
| 1800 | } |
| 1801 | } |
| 1802 | |
| 1803 | /// Reference bindings cannot outlive temporary storage, also when they are set. |
| 1804 | @test unsafe fn testLocalReferenceStorage() throws (testing::TestError) { |
| 1805 | try expectProgramError( |
| 1806 | "record R: Copy { n: u32 } fn make() -> R { return R { n: 4 }; } fn run() { let p: &u32 = &make().n; }", |
| 1807 | resolver::ErrorKind::RefBinding |
| 1808 | ); |
| 1809 | // A temporary holds a local region, which no reference local's region fits. |
| 1810 | try expectProgramError( |
| 1811 | "record R: Copy { n: u32 } fn make() -> R { return R { n: 4 }; } fn run() { let n: u32 = 4; let mut p: &u32 = &n; set p = &make().n; }", |
| 1812 | resolver::ErrorKind::Region(resolver::RegionError::Mismatch) |
| 1813 | ); |
| 1814 | } |
| 1815 | |
| 1816 | /// Stored and returned values cannot contain a local reference. |
| 1817 | @test unsafe fn testLocalReferenceEscapeRejected() throws (testing::TestError) { |
| 1818 | let programs = &[ |
| 1819 | "fn run() -> *u32 { let n: u32 = 1; let p = &n; return p; }", |
| 1820 | "fn run() -> *u32 { let n: u32 = 1; let p = &n; return p as *u32; }", |
| 1821 | "static DATA: u32 = 0; static P: *u32 = &DATA; fn run() { let n: u32 = 1; let p = &n; set P = p; }", |
| 1822 | "record R: Copy { p: *u32 } fn run() { let n: u32 = 1; let p = &n; let r = R { p }; }", |
| 1823 | ]; |
| 1824 | for program in programs { |
| 1825 | let mut a = testResolver(); |
| 1826 | let result = try resolveProgramStr(&mut a, program); |
| 1827 | try expectError(&result); |
| 1828 | } |
| 1829 | } |
| 1830 | |
| 1831 | /// Pointer indirection cannot prove that sibling pointees are disjoint. |
| 1832 | @test unsafe fn testIndirectFieldBorrowConflict() throws (testing::TestError) { |
| 1833 | let programs = &[ |
| 1834 | "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } fn take(a: &mut u32, b: &mut u32) {} unsafe fn run(r: &mut R) { take(&mut *r.a, &mut *r.b); }", |
| 1835 | "record R: Copy { a: *unsafe mut u32, b: *unsafe mut u32 } unsafe fn run(r: &mut R) { let a: &mut u32 = &mut *r.a; let b: &mut u32 = &mut *r.b; }", |
| 1836 | ]; |
| 1837 | for program in programs { |
| 1838 | let mut a = testResolver(); |
| 1839 | let result = try resolveProgramStr(&mut a, program); |
| 1840 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("r")); |
| 1841 | } |
| 1842 | } |
| 1843 | |
| 1844 | /// A path through an owned mutable slice or pointer field reaches storage that only that field |
| 1845 | /// owns, |
| 1846 | /// so it stays distinct from sibling fields, including an allocator borrowed from one of them. |
| 1847 | @test unsafe fn testIndexedFieldBorrowsDisjoint() throws (testing::TestError) { |
| 1848 | let programs = &[ |
| 1849 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.xs[0].f, &mut g.ys[1]); }", |
| 1850 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.xs[0].f, &mut g.n); }", |
| 1851 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { let r = &mut g.xs[0].f; set g.ys[1] = 2; set *r = 3; }", |
| 1852 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { let r = &mut g.xs[0]; let s = &mut g.ys; set r.f = 3; }", |
| 1853 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: *mut G) { take(&mut g.xs[0].f, &mut g.ys[1]); }", |
| 1854 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn (i: &mut Item) add(m: &mut u32) {} fn run(g: &mut G) { g.xs[0].add(&mut g.n); }", |
| 1855 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn (i: &mut Item) add(m: &mut u32) {} fn run(g: &mut G) { g.xs[0].add(&mut g.ys[0]); }", |
| 1856 | "record Item: Copy { x: u32 } record Holder { blocks: *mut [Item], pool: *mut [u32] } fn bump(p: &mut [u32], v: u32) {} fn run(h: &mut Holder) { let r = &h.blocks[0].x; let v = *r; bump(&mut h.pool[..], v); }", |
| 1857 | "record P { n: u32 } record G { p: *mut P, q: *mut P } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.p.n, &mut g.q.n); }", |
| 1858 | "record P { n: u32 } record G { p: *mut P, q: *mut P } fn take(a: &mut *mut P, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.p, &mut g.q.n); }", |
| 1859 | "record P { n: u32 } record G { p: *mut P, q: *mut P } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut (*g.p).n, &mut (*g.q).n); }", |
| 1860 | "record I { xs: *mut [u32], n: u32 } record G { i: I, j: I } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.i.xs[0], &mut g.j.xs[0]); take(&mut g.i.xs[0], &mut g.i.n); }", |
| 1861 | "union U: Copy { A(u32), B } record G { us: *mut [U], n: u32 } fn run(g: &mut G) { match &mut g.us[0] { case U::A(p) => { set g.n = *p; } else => {} } }", |
| 1862 | ]; |
| 1863 | for program in programs { |
| 1864 | let mut a = testResolver(); |
| 1865 | let result = try resolveProgramStr(&mut a, program); |
| 1866 | try expectNoErrors(&result); |
| 1867 | } |
| 1868 | } |
| 1869 | |
| 1870 | /// Places that can reach the same element or field stay in conflict, whichever fields lie behind an |
| 1871 | /// index. |
| 1872 | @test unsafe fn testIndexedFieldBorrowsOverlap() throws (testing::TestError) { |
| 1873 | let programs = &[ |
| 1874 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn take2(s: &mut *mut [u32], n: u32) {} fn run(g: &mut G) { take2(&mut g.ys, g.ys[0]); }", |
| 1875 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn take2(s: &mut [u32], n: u32) {} fn run(g: &mut G) { take2(&mut g.ys[..], g.ys[0]); }", |
| 1876 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.ys[0], &mut g.ys[1]); }", |
| 1877 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { take(&mut g.xs[0].f, &mut g.xs[1].f); }", |
| 1878 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { let r = &mut g.ys[0]; set g.ys[1] = 2; set *r = 1; }", |
| 1879 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn run(g: &mut G) { let r = &mut g.xs[0]; let s = &mut g.xs[1]; set r.f = 3; }", |
| 1880 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn take2(a: &mut u32, b: &mut G) {} fn run(g: &mut G) { take2(&mut g.ys[0], g); }", |
| 1881 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn (i: &mut Item) add(m: &mut u32) {} fn run(g: &mut G) { g.xs[0].add(&mut g.xs[1].f); }", |
| 1882 | "record Item: Copy { f: u32 } record G { xs: *mut [Item], ys: *mut [u32], n: u32 } fn take(a: &mut u32, b: &mut u32) {} fn take2(a: &mut *mut [Item], b: &mut u32) {} fn run(g: &mut G) { take2(&mut g.xs, &mut g.xs[0].f); }", |
| 1883 | "record P { n: u32 } record G { p: *mut P } fn take(a: &mut *mut P, b: &u32) {} fn run(g: &mut G) { take(&mut g.p, &g.p.n); }", |
| 1884 | "union U: Copy { A(u32), B } record G { us: *mut [U], n: u32 } fn run(g: &mut G) { match &mut g.us[0] { case U::A(p) => { set g.us[1] = U::B; *p; } else => {} } }", |
| 1885 | ]; |
| 1886 | for program in programs { |
| 1887 | let mut a = testResolver(); |
| 1888 | let result = try resolveProgramStr(&mut a, program); |
| 1889 | let error = try expectError(&result); |
| 1890 | let case resolver::ErrorKind::BorrowConflict(_) = error.kind |
| 1891 | else throw testing::TestError::Failed; |
| 1892 | } |
| 1893 | } |
| 1894 | |
| 1895 | /// An unsafe or copyable owned pointer can alias another field, so a path through it covers the |
| 1896 | /// whole root. |
| 1897 | @test unsafe fn testPointerFieldPathCoversRoot() throws (testing::TestError) { |
| 1898 | let programs = &[ |
| 1899 | "record R: Copy { a: *unsafe mut [u32], b: *unsafe mut [u32] } fn take(x: &mut u32, y: &mut u32) {} unsafe fn run(r: &mut R) { take(&mut r.a[0], &mut r.b[0]); }", |
| 1900 | "record P { xs: *mut [u32] } record Q: Copy { p: *unsafe mut P, n: u32 } fn take(x: &mut u32, y: &mut u32) {} unsafe fn run(q: &mut Q) { take(&mut q.p.xs[0], &mut q.n); }", |
| 1901 | "record P { n: u32 } record Q: Copy { p: *unsafe mut P, n: u32 } fn take(x: &mut u32, y: &mut u32) {} unsafe fn run(q: &mut Q) { take(&mut q.p.n, &mut q.n); }", |
| 1902 | "record P { n: u32 } record Q: Copy { p: *P, n: u32 } fn take(x: &mut u32, y: u32) {} fn run(q: &mut Q) { take(&mut q.n, q.p.n); }", |
| 1903 | "record Q: Copy { xs: *[u32], n: u32 } fn take(x: &mut u32, y: u32) {} fn run(q: &mut Q) { take(&mut q.n, q.xs[0]); }", |
| 1904 | ]; |
| 1905 | for program in programs { |
| 1906 | let mut a = testResolver(); |
| 1907 | let result = try resolveProgramStr(&mut a, program); |
| 1908 | let error = try expectError(&result); |
| 1909 | let case resolver::ErrorKind::BorrowConflict(_) = error.kind |
| 1910 | else throw testing::TestError::Failed; |
| 1911 | } |
| 1912 | } |
| 1913 | |
| 1914 | /// Pattern references protect their field and permit writes to disjoint fields. |
| 1915 | @test unsafe fn testDisjointPatternFieldBorrow() throws (testing::TestError) { |
| 1916 | let mut a = testResolver(); |
| 1917 | let result = try resolveProgramStr( |
| 1918 | &mut a, |
| 1919 | "union U: Copy { A(u32), B } record R: Copy { u: U, n: u32 } fn run(r: &mut R) { let alias = &mut r.u; match alias { case U::A(p) => { set *alias = U::B; *p; } else => {} } }" |
| 1920 | ); |
| 1921 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("r")); |
| 1922 | } |
| 1923 | |
| 1924 | /// Slice mutations must preserve storage held by a local reference. |
| 1925 | @test unsafe fn testLocalReferenceSliceMutationRejected() throws (testing::TestError) { |
| 1926 | let programs = &[ |
| 1927 | "fn run(owned: *mut [u8]) { let mut s = owned; let p: &u8 = &s[0]; s.delete(0); }", |
| 1928 | "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn run(owned: *mut [u8], a: &Heap) { let mut s = owned; let p: &u8 = &s[0]; try! s.append(1, a); }", |
| 1929 | ]; |
| 1930 | for program in programs { |
| 1931 | let mut a = testResolver(); |
| 1932 | let result = try resolveProgramStr(&mut a, program); |
| 1933 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("s")); |
| 1934 | } |
| 1935 | } |
| 1936 | |
| 1937 | /// Owner moves and mutable methods cannot invalidate a local loan. |
| 1938 | @test unsafe fn testLocalReferenceOwnerMutationRejected() throws (testing::TestError) { |
| 1939 | let programs = &[ |
| 1940 | "fn run(p: *mut u32) { let r: &u32 = &*p; let moved = p; }", |
| 1941 | "record R: Copy { a: u32 } fn (p: &mut R) change() { set p.a = 1; } fn run(p: &mut R) { let r = &p.a; p.change(); }", |
| 1942 | ]; |
| 1943 | for program in programs { |
| 1944 | let mut a = testResolver(); |
| 1945 | let result = try resolveProgramStr(&mut a, program); |
| 1946 | try expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("p")); |
| 1947 | } |
| 1948 | } |
| 1949 | |
| 1950 | /// Reference locals require a function scope and a reachable initializer result. |
| 1951 | @test unsafe fn testLocalReferenceDeclarationContext() throws (testing::TestError) { |
| 1952 | let mut a = testResolver(); |
| 1953 | let result = try resolveProgramStr(&mut a, "let n: u32 = 1; let p: &u32 = &n;"); |
| 1954 | try expectErrorKind(&result, resolver::ErrorKind::InvalidRefPosition); |
| 1955 | } |
| 1956 | |
| 1957 | /// Allocating append requires an explicit error handler. |
| 1958 | @test unsafe fn testSliceAppendRequiresTry() throws (testing::TestError) { |
| 1959 | let mut a = testResolver(); |
| 1960 | let program = |
| 1961 | "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn run(owned: *mut [u8], a: &Heap) { let mut s = owned; s.append(1, a); }"; |
| 1962 | let result = try resolveProgramStr(&mut a, program); |
| 1963 | try expectErrorKind(&result, resolver::ErrorKind::MissingTry); |
| 1964 | } |
| 1965 | |
| 1966 | /// Append propagation requires every allocator error in the caller's throw list. |
| 1967 | @test unsafe fn testSliceAppendIncompatibleError() throws (testing::TestError) { |
| 1968 | let mut a = testResolver(); |
| 1969 | let program = |
| 1970 | "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} union F: Copy { Invalid } fn run(owned: *mut [u8], a: &Heap) throws (F) { let mut s = owned; try s.append(1, a); }"; |
| 1971 | let result = try resolveProgramStr(&mut a, program); |
| 1972 | try expectErrorKind(&result, resolver::ErrorKind::TryIncompatibleError); |
| 1973 | } |
| 1974 | |
| 1975 | /// Invalid calls in function bodies retain their resolution diagnostics. |
| 1976 | @test unsafe fn testInvalidBodyCalls() throws (testing::TestError) { |
| 1977 | for program in &[ |
| 1978 | "fn f(x: u32) {} fn g() { f(1, 2); }", |
| 1979 | "fn f(x: u32) {} fn g() { if true { f(1, 2); } }", |
| 1980 | "fn f(x: u32) {} unsafe fn g() { f(1, 2); }", |
| 1981 | "fn f(x: u32) -> u32 { return x; } fn g() { f(f(1, 2)); }", |
| 1982 | ] { |
| 1983 | let mut res = testResolver(); |
| 1984 | let result = try resolveProgramStr(&mut res, program); |
| 1985 | try expectErrorKind(&result, resolver::ErrorKind::FnArgCountMismatch( |
| 1986 | resolver::CountMismatch { |
| 1987 | expected: 1, actual: 2 |
| 1988 | } |
| 1989 | )); |
| 1990 | } |
| 1991 | } |
| 1992 | |
| 1993 | /// Unsafe calls with excess arguments report the unsafe-call diagnostic. |
| 1994 | @test unsafe fn testInvalidUnsafeBodyCall() throws (testing::TestError) { |
| 1995 | let mut res = testResolver(); |
| 1996 | let result = try resolveProgramStr( |
| 1997 | &mut res, "unsafe fn f(x: u32) {} fn g() { f(1, 2); }" |
| 1998 | ); |
| 1999 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeCall); |
| 2000 | } |
| 2001 | |
| 2002 | /// Iteration over raw slices requires permission to read their storage. |
| 2003 | @test unsafe fn testRawSliceIterationRequiresUnsafe() throws (testing::TestError) { |
| 2004 | for program in [ |
| 2005 | "fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }", |
| 2006 | "fn f(p: *unsafe mut [u32]) { for item, index in p { assert item == index; } }", |
| 2007 | "record R { items: *unsafe [u32] } fn f(r: &R) { for item in r.items { assert item == 0; } }", |
| 2008 | ] { |
| 2009 | let mut res = testResolver(); |
| 2010 | let result = try resolveProgramStr(&mut res, program); |
| 2011 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 2012 | } |
| 2013 | } |
| 2014 | |
| 2015 | /// Checked iteration is safe, and raw iteration accepts explicit permission. |
| 2016 | @test unsafe fn testSliceIterationPermissions() throws (testing::TestError) { |
| 2017 | for program in [ |
| 2018 | "unsafe fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }", |
| 2019 | "fn f(p: *unsafe [u32]) { unsafe { for item in p { assert item == 0; } } }", |
| 2020 | "fn f(p: &[u32]) { for item in p { assert item == 0; } }", |
| 2021 | "fn f(p: &mut [u32]) { for item, index in p { assert item == index; } }", |
| 2022 | "fn f(p: [u32; 2]) { for item in p { assert item == 0; } }", |
| 2023 | ] { |
| 2024 | let mut res = testResolver(); |
| 2025 | let result = try resolveProgramStr(&mut res, program); |
| 2026 | try expectNoErrors(&result); |
| 2027 | } |
| 2028 | } |
| 2029 | |
| 2030 | /// Short-circuit paths must agree on exact-use ownership. |
| 2031 | @test unsafe fn testShortCircuitOwnership() throws (testing::TestError) { |
| 2032 | for program in [ |
| 2033 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = false and take(t); }", |
| 2034 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = true or take(t); }", |
| 2035 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket, flag: bool) { let result = flag and take(t); }", |
| 2036 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } unsafe fn f(t: Ticket, flag: bool) { let result = flag or take(t); }", |
| 2037 | ] { |
| 2038 | let mut res = testResolver(); |
| 2039 | let result = try resolveProgramStr(&mut res, program); |
| 2040 | let error = try expectError(&result); |
| 2041 | let case resolver::ErrorKind::LinearBranchMismatch(_) = error.kind |
| 2042 | else throw testing::TestError::Failed; |
| 2043 | } |
| 2044 | } |
| 2045 | |
| 2046 | /// The left operand executes on every short-circuit path. |
| 2047 | @test unsafe fn testShortCircuitLeftConsumption() throws (testing::TestError) { |
| 2048 | for program in [ |
| 2049 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = take(t) and false; }", |
| 2050 | "union Ticket: Once { Value(u32) } fn take(t: Ticket) -> bool { match t { case Ticket::Value(n) => return n == 1, } } fn f(t: Ticket) { let result = take(t) or true; }", |
| 2051 | ] { |
| 2052 | let mut res = testResolver(); |
| 2053 | let result = try resolveProgramStr(&mut res, program); |
| 2054 | try expectNoErrors(&result); |
| 2055 | } |
| 2056 | } |
| 2057 | |
| 2058 | /// Earlier reference arguments protect their storage during later arguments. |
| 2059 | @test unsafe fn testCallArgumentLoans() throws (testing::TestError) { |
| 2060 | for program in [ |
| 2061 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (p: &mut u32) { outer(&mut *p, inner(p)); }", |
| 2062 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32) { outer(&*p, inner(p)); }", |
| 2063 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} unsafe fn f (p: &mut u32) { outer(&mut *p, inner(p)); }", |
| 2064 | "record R { n: u32 } fn (r: &mut R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f (r: &mut R) { (&mut *r).call(inner(&mut r.n)); }", |
| 2065 | ] { |
| 2066 | let mut res = testResolver(); |
| 2067 | let result = try resolveProgramStr(&mut res, program); |
| 2068 | let error = try expectError(&result); |
| 2069 | let case resolver::ErrorKind::BorrowConflict(_) = error.kind |
| 2070 | else throw testing::TestError::Failed; |
| 2071 | } |
| 2072 | } |
| 2073 | |
| 2074 | /// Conditional explicit arguments protect every possible borrowed place. |
| 2075 | @test unsafe fn testConditionalCallArgumentLoans() throws (testing::TestError) { |
| 2076 | for program in [ |
| 2077 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(p)); }", |
| 2078 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }", |
| 2079 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *p); }", |
| 2080 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }", |
| 2081 | "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *q); }", |
| 2082 | "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer((&*p if flag else &*q) as &u32, inner(p)); }", |
| 2083 | "record R { n: u32 } fn (r: &R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f (p: &mut R, q: &mut R, flag: bool) { (&*p if flag else &*q).call(inner(&mut q.n)); }", |
| 2084 | ] { |
| 2085 | let mut res = testResolver(); |
| 2086 | let result = try resolveProgramStr(&mut res, program); |
| 2087 | let error = try expectError(&result); |
| 2088 | let case resolver::ErrorKind::BorrowConflict(_) = error.kind |
| 2089 | else throw testing::TestError::Failed; |
| 2090 | } |
| 2091 | } |
| 2092 | |
| 2093 | /// Conditional argument alternatives cannot overlap another exclusive argument. |
| 2094 | @test unsafe fn testConditionalCallArgumentOverlap() throws (testing::TestError) { |
| 2095 | for program in [ |
| 2096 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, p); }", |
| 2097 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q); }", |
| 2098 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p, p if flag else q); }", |
| 2099 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(q, p if flag else q); }", |
| 2100 | "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, p); }", |
| 2101 | "fn outer(p: &u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q); }", |
| 2102 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(p if flag else q, q if flag else p); }", |
| 2103 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, r: &mut u32, a: bool, b: bool) { outer((p if a else q) if b else r, q); }", |
| 2104 | "fn outer(p: &u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer((p if flag else q) as &u32, p); }", |
| 2105 | "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f (p: &mut R, q: &mut R, flag: bool) { (p if flag else q).call(p); }", |
| 2106 | "trait R { fn (&mut R) call(p: &opaque R); } fn f (p: &mut opaque R, q: &mut opaque R, flag: bool) { (p if flag else q).call(q); }", |
| 2107 | ] { |
| 2108 | let mut res = testResolver(); |
| 2109 | let result = try resolveProgramStr(&mut res, program); |
| 2110 | let error = try expectError(&result); |
| 2111 | let case resolver::ErrorKind::BorrowConflict(_) = error.kind |
| 2112 | else throw testing::TestError::Failed; |
| 2113 | } |
| 2114 | } |
| 2115 | |
| 2116 | /// Conditional argument alternatives permit shared access and disjoint places. |
| 2117 | @test unsafe fn testConditionalCallArgumentSeparation() throws (testing::TestError) { |
| 2118 | for program in [ |
| 2119 | "fn outer(p: &u32, q: &u32) {} fn f (p: &u32, q: &u32, flag: bool) { outer(p if flag else q, p); }", |
| 2120 | "fn outer(p: &mut u32, q: &mut u32) {} fn f (p: &mut u32, q: &mut u32, r: &mut u32, flag: bool) { outer(p if flag else q, r); }", |
| 2121 | "record R { a: u32, b: u32, c: u32 } fn outer(p: &mut u32, q: &mut u32) {} fn f (r: &mut R, flag: bool) { outer(&mut r.a if flag else &mut r.b, &mut r.c); }", |
| 2122 | "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f (p: &mut R, q: &mut R, r: &R, flag: bool) { (p if flag else q).call(r); }", |
| 2123 | ] { |
| 2124 | let mut res = testResolver(); |
| 2125 | let result = try resolveProgramStr(&mut res, program); |
| 2126 | try expectNoErrors(&result); |
| 2127 | } |
| 2128 | } |
| 2129 | |
| 2130 | /// Call loans allow shared reads, separate fields, and access after the call. |
| 2131 | @test unsafe fn testCallArgumentLoanScopes() throws (testing::TestError) { |
| 2132 | for program in [ |
| 2133 | "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32, q: &mut u32, flag: bool) { outer(&*p if flag else &*q, read(p)); set *p = 3; set *q = 4; }", |
| 2134 | "record R { a: u32, b: u32, c: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (r: &mut R, flag: bool) { outer(&mut r.a if flag else &mut r.b, inner(&mut r.c)); set r.a = 3; }", |
| 2135 | "fn outer(p: &mut u32, n: u32) {} fn f (p: &mut u32, flag: bool) { outer(&mut *p if flag else &mut *p, 0); set *p = 3; }", |
| 2136 | "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f (p: &mut u32) { outer(&*p, read(p)); set *p = 3; }", |
| 2137 | "record R { a: u32, b: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f (r: &mut R) { outer(&mut r.a, inner(&mut r.b)); set r.a = 3; }", |
| 2138 | ] { |
| 2139 | let mut res = testResolver(); |
| 2140 | let result = try resolveProgramStr(&mut res, program); |
| 2141 | try expectNoErrors(&result); |
| 2142 | } |
| 2143 | } |
| 2144 | |
| 2145 | /// Owned slices and elements reached through a borrow cannot escape as owned pointers. |
| 2146 | @test unsafe fn testBorrowedOwnedPlaceEscapeRejected() throws (testing::TestError) { |
| 2147 | for program in [ |
| 2148 | "record G { e: *mut [u32] } fn f(g: &G) -> *[u32] { return &g.e[..]; }", |
| 2149 | "record G { e: *mut [u32] } fn f(g: &mut G) -> *mut [u32] { return &mut g.e[..]; }", |
| 2150 | "record G { e: *mut [u32] } fn f(g: &G) -> *u32 { return &g.e[0]; }", |
| 2151 | "record G { e: *mut [u32] } fn f(g: &mut G) -> *mut u32 { return &mut g.e[0]; }", |
| 2152 | "record G { e: *mut [u32] } fn f(g: &G) -> *[u32] { let s: *[u32] = &g.e[..]; return s; }", |
| 2153 | ] { |
| 2154 | let mut res = testResolver(); |
| 2155 | let result = try resolveProgramStr(&mut res, program); |
| 2156 | try expectError(&result); |
| 2157 | } |
| 2158 | } |
| 2159 | |
| 2160 | /// Owned roots keep owned address classes, and borrowed slices may be used locally. |
| 2161 | @test unsafe fn testOwnedRootAddressClassAllowed() throws (testing::TestError) { |
| 2162 | for program in [ |
| 2163 | "fn f(nodes: *mut [u32]) -> *mut u32 { return &mut nodes[0]; }", |
| 2164 | "fn f() -> *mut u32 { let mut nodes: *mut [u32] = &mut []; return &mut nodes[0]; }", |
| 2165 | "record G { e: *mut [u32] } fn f(g: *mut G) -> *mut [u32] { return &mut g.e[..]; }", |
| 2166 | "record G { e: *mut [u32], n: u32 } fn freeze(g: G) -> *[u32] { return &g.e[..g.n]; }", |
| 2167 | "record G { e: *mut [u32], n: u32 } fn f(g: &G) -> u32 { let s: &[u32] = &g.e[..g.n]; return s[0]; }", |
| 2168 | ] { |
| 2169 | let mut res = testResolver(); |
| 2170 | let result = try resolveProgramStr(&mut res, program); |
| 2171 | try expectNoErrors(&result); |
| 2172 | } |
| 2173 | } |
| 2174 | |
| 2175 | /// Coercing a move-only place to a Copy type moves the place. |
| 2176 | @test unsafe fn testMoveOnlyFieldCoercionIsMove() throws (testing::TestError) { |
| 2177 | for program in [ |
| 2178 | "record G { e: *mut [u32] } fn f(g: &G) -> *[u32] { let s: *[u32] = g.e; return s; }", |
| 2179 | "record G { e: *mut [u32] } fn f(g: G) -> *[u32] { let s: *[u32] = g.e; return s; }", |
| 2180 | "record G { e: *mut u32 } fn f(g: &G) { let s: *u32 = g.e; }", |
| 2181 | "record G { e: *mut [u32] } fn f(g: &G) { let mut s: *[u32] = &[]; set s = g.e; }", |
| 2182 | ] { |
| 2183 | let mut res = testResolver(); |
| 2184 | let result = try resolveProgramStr(&mut res, program); |
| 2185 | try expectErrorKind(&result, resolver::ErrorKind::LinearPartialMove); |
| 2186 | } |
| 2187 | } |
| 2188 | |
| 2189 | /// A loop over a slice copies each element out, so it cannot iterate move-only elements, as a |
| 2190 | /// subscript cannot move one out. |
| 2191 | @test unsafe fn testForLoopOverMoveOnlySliceRejected() throws (testing::TestError) { |
| 2192 | for program in [ |
| 2193 | "union File: Once { Open(u32) } fn close(f: File) { match f { case File::Open(_) => {} } } fn f(fs: &[File]) { for x in fs { close(x); } }", |
| 2194 | "fn f(rs: &[*mut u32]) { for p in rs { set *p = 1; } }", |
| 2195 | "fn f(rs: *[*mut u32]) { for p in rs { set *p = 1; } }", |
| 2196 | "fn steal(rs: &mut [*mut u32]) -> ?*mut u32 { for p in rs { return p; } return nil; }", |
| 2197 | "fn f(rs: *mut [*mut u32]) { for p in rs { set *p = 1; } }", |
| 2198 | "record R { x: u32 } fn keep(r: R) {} fn f(rs: &[R]) { for r in rs { keep(r); } }", |
| 2199 | ] { |
| 2200 | let mut res = testResolver(); |
| 2201 | let result = try resolveProgramStr(&mut res, program); |
| 2202 | try expectErrorKind(&result, resolver::ErrorKind::LinearPartialMove); |
| 2203 | } |
| 2204 | } |
| 2205 | |
| 2206 | /// Loops over slices of Copy elements, and over owned arrays of move-only elements, are allowed. |
| 2207 | @test unsafe fn testForLoopOverCopySliceAllowed() throws (testing::TestError) { |
| 2208 | for program in [ |
| 2209 | "record R: Copy { x: u32 } fn f(rs: &[R]) -> u32 { let mut n: u32 = 0; for r in rs { set n += r.x; } return n; }", |
| 2210 | "fn f(rs: &[*u32]) -> u32 { let mut n: u32 = 0; for p in rs { set n += *p; } return n; }", |
| 2211 | "fn keep(p: *mut u32) {} fn f(a: [*mut u32; 2]) { for p in a { keep(p); } }", |
| 2212 | ] { |
| 2213 | let mut res = testResolver(); |
| 2214 | let result = try resolveProgramStr(&mut res, program); |
| 2215 | try expectNoErrors(&result); |
| 2216 | } |
| 2217 | } |
| 2218 | |
| 2219 | /// Moved owned pointers may be coerced to Copy pointers, since the source is consumed. |
| 2220 | @test unsafe fn testMovedOwnedPointerCoercionAllowed() throws (testing::TestError) { |
| 2221 | for program in [ |
| 2222 | "fn f(p: *mut [u32]) -> *[u32] { return p; }", |
| 2223 | "fn f(p: *mut u32) -> *u32 { let q: *u32 = p; return q; }", |
| 2224 | "fn f(p: *mut u32) -> *u32 { return p as *u32; }", |
| 2225 | ] { |
| 2226 | let mut res = testResolver(); |
| 2227 | let result = try resolveProgramStr(&mut res, program); |
| 2228 | try expectNoErrors(&result); |
| 2229 | } |
| 2230 | } |
| 2231 | |
| 2232 | /// Casts cannot change pointer class or add mutability, even in unsafe code. |
| 2233 | @test unsafe fn testAsCastClassAndMutabilityRejected() throws (testing::TestError) { |
| 2234 | for program in [ |
| 2235 | "fn f(x: &u32) { let r = x as *u32; }", |
| 2236 | "fn f(x: &mut u32) { let r = x as *mut u32; }", |
| 2237 | "fn f(p: *u32) { let r = p as *mut u32; }", |
| 2238 | "fn f(p: *mut u32) { let r = p as &mut u32; }", |
| 2239 | "fn f(p: *u32) { let r = p as &u32; }", |
| 2240 | "fn f(p: *mut [u32]) { let r = p as &mut [u32]; }", |
| 2241 | "fn f(x: &u32) { let r = x as &mut u32; }", |
| 2242 | "fn f(x: &[u32]) { let r = x as *[u32]; }", |
| 2243 | "fn f(p: *u32) { let r = p as ?*u32; }", |
| 2244 | "fn f(p: u64) { let r = p as *u32; }", |
| 2245 | "unsafe fn f(p: *unsafe u32) { let r = p as *u32; }", |
| 2246 | "unsafe fn f(p: *unsafe u32) { let r = p as *mut u32; }", |
| 2247 | "unsafe fn f(p: *unsafe u32) { let r = p as *unsafe mut u32; }", |
| 2248 | "unsafe fn f(p: &u32) { let r = p as *u32; }", |
| 2249 | "unsafe fn f(p: *unsafe [u32]) { let r = p as *[u32]; }", |
| 2250 | "unsafe fn f(p: *unsafe u32) { let r = p as &u32; }", |
| 2251 | "unsafe fn f(x: &mut u32) { let r = x as *mut u32; }", |
| 2252 | ] { |
| 2253 | let mut res = testResolver(); |
| 2254 | let result = try resolveProgramStr(&mut res, program); |
| 2255 | let err = try expectError(&result); |
| 2256 | let case resolver::ErrorKind::InvalidAsCast(_) = err.kind |
| 2257 | else throw testing::TestError::Failed; |
| 2258 | } |
| 2259 | } |
| 2260 | |
| 2261 | /// Casts that reinterpret element types, opaque types, or raw pointers require unsafe. |
| 2262 | @test unsafe fn testAsCastUnsafeOperationsRejected() throws (testing::TestError) { |
| 2263 | for program in [ |
| 2264 | "fn f(x: &u32) { let r = x as *unsafe u32; }", |
| 2265 | "fn f(p: *[u32]) { let r = p as *[u8]; }", |
| 2266 | "fn f(p: *opaque) { let r = p as *u32; }", |
| 2267 | "fn f(p: *u32) { let r = p as *u8; }", |
| 2268 | "fn f(x: &opaque) { let r = x as &u32; }", |
| 2269 | ] { |
| 2270 | let mut res = testResolver(); |
| 2271 | let result = try resolveProgramStr(&mut res, program); |
| 2272 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 2273 | } |
| 2274 | } |
| 2275 | |
| 2276 | /// Casts of a move-only field move it, so a borrowed or owned field cannot be cast out. |
| 2277 | @test unsafe fn testAsCastFieldMoveRejected() throws (testing::TestError) { |
| 2278 | for program in [ |
| 2279 | "record G { e: *mut [u32] } fn f(g: G) { let r = g.e as *[u32]; }", |
| 2280 | "record G { e: *mut [u32] } fn f(g: &G) { let r = g.e as *[u32]; }", |
| 2281 | ] { |
| 2282 | let mut res = testResolver(); |
| 2283 | let result = try resolveProgramStr(&mut res, program); |
| 2284 | try expectErrorKind(&result, resolver::ErrorKind::LinearPartialMove); |
| 2285 | } |
| 2286 | } |
| 2287 | |
| 2288 | /// Casts that keep class and mutability, or only widen to opaque or numeric types, are allowed. |
| 2289 | @test unsafe fn testAsCastSafeCasesAllowed() throws (testing::TestError) { |
| 2290 | for program in [ |
| 2291 | "fn f(p: *u32) { let r = p as *opaque; }", |
| 2292 | "fn f(p: *mut u32) { let r = p as *mut opaque; }", |
| 2293 | "fn f(x: &mut u32) { let r = x as &u32; }", |
| 2294 | "fn f(p: *u32) -> u64 { return p as u64; }", |
| 2295 | "fn f(x: &u32) -> u64 { return x as u64; }", |
| 2296 | ] { |
| 2297 | let mut res = testResolver(); |
| 2298 | let result = try resolveProgramStr(&mut res, program); |
| 2299 | try expectNoErrors(&result); |
| 2300 | } |
| 2301 | try expectAnalyzeOk("unsafe fn f(x: &u32) { let r = x as *unsafe u32; }"); |
| 2302 | } |
| 2303 | |
| 2304 | /// Immutable owned pointers reached through a reference keep their owned class. |
| 2305 | @test unsafe fn testBorrowedImmutableOwnedPlaceAllowed() throws (testing::TestError) { |
| 2306 | for program in [ |
| 2307 | "record G { s: *[u32] } fn f(g: &G) -> *[u32] { return &g.s[..]; }", |
| 2308 | "record G { s: *[u32] } fn f(g: &G) -> *u32 { return &g.s[0]; }", |
| 2309 | ] { |
| 2310 | let mut res = testResolver(); |
| 2311 | let result = try resolveProgramStr(&mut res, program); |
| 2312 | try expectNoErrors(&result); |
| 2313 | } |
| 2314 | } |
| 2315 | |
| 2316 | /// Inside unsafe code, owned pointers may be derived through references. |
| 2317 | @test unsafe fn testUnsafeBorrowedOwnedPlaceAllowed() throws (testing::TestError) { |
| 2318 | for program in [ |
| 2319 | "record G { e: *mut [u32] } fn f(g: &G) -> *[u32] { unsafe { return &g.e[..]; } }", |
| 2320 | "record G { e: *mut [u32] } fn f(g: &mut G) -> *mut [u32] { unsafe { return &mut g.e[..]; } }", |
| 2321 | "record G { e: *mut [u32] } unsafe fn f(g: &G) -> *u32 { return &g.e[0]; }", |
| 2322 | ] { |
| 2323 | let mut res = testResolver(); |
| 2324 | let result = try resolveProgramStr(&mut res, program); |
| 2325 | try expectNoErrors(&result); |
| 2326 | } |
| 2327 | } |
| 2328 | |
| 2329 | /// A second owned derivation from the same owned root is a use after the first moved it. |
| 2330 | @test unsafe fn testOwnedRootSecondDerivationRejected() throws (testing::TestError) { |
| 2331 | for program in [ |
| 2332 | "fn f() { let mut s: *mut [u32] = &mut []; let a: *mut u32 = &mut s[0]; let b: *mut u32 = &mut s[0]; }", |
| 2333 | "fn f(s: *mut [u32]) { let a: *mut [u32] = &mut s[..]; let b: *mut [u32] = &mut s[..]; }", |
| 2334 | "fn f(s: *mut u32) { let a: *mut u32 = &mut *s; let b: *mut u32 = &mut *s; }", |
| 2335 | "fn f() { let mut s: *mut [u32] = &mut []; let a = &mut s[0]; let b = &mut s[0]; }", |
| 2336 | "record G { e: *mut [u32], n: u32 } fn f(g: G) { let a: *mut [u32] = &mut g.e[..]; let b: *mut [u32] = &mut g.e[..]; }", |
| 2337 | "record G { e: *mut [u32] } fn f(p: *mut G) { let x: *mut [u32] = &mut p.e[..]; let y: *mut [u32] = &mut p.e[..]; }", |
| 2338 | "record G { e: *mut [u32] } fn f(p: *mut G) { let x: *mut u32 = &mut p.e[0]; let y: *mut [u32] = &mut p.e[..]; }", |
| 2339 | ] { |
| 2340 | let mut res = testResolver(); |
| 2341 | let result = try resolveProgramStr(&mut res, program); |
| 2342 | let err = try expectError(&result); |
| 2343 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2344 | else throw testing::TestError::Failed; |
| 2345 | } |
| 2346 | } |
| 2347 | |
| 2348 | /// An immutable owned view of mutable owned storage moves the root, so the root cannot be written. |
| 2349 | @test unsafe fn testOwnedRootViewThenWriteRejected() throws (testing::TestError) { |
| 2350 | for program in [ |
| 2351 | "fn f() { let mut s: *mut [u32] = &mut []; let v: *[u32] = &s[..]; set s[0] = 3; }", |
| 2352 | "fn f(s: *mut [u32]) { let v: *[u32] = &s[..]; set s[0] = 3; }", |
| 2353 | "fn f(s: *mut [u32]) { let v: *u32 = &s[0]; set s[1] = 3; }", |
| 2354 | "record G { e: *mut [u32], n: u32 } fn f(g: G) { let v: *[u32] = &g.e[..g.n]; set g.e[0] = 1; }", |
| 2355 | "record G { e: *mut [u32] } fn f(p: *mut G) { let v: *[u32] = &p.e[..]; set p.e[0] = 1; }", |
| 2356 | "record G { e: *mut [u32] } fn f(p: *mut G) { let v: *[u32] = &p.e[..]; let w: *[u32] = &p.e[..]; }", |
| 2357 | ] { |
| 2358 | let mut res = testResolver(); |
| 2359 | let result = try resolveProgramStr(&mut res, program); |
| 2360 | let err = try expectError(&result); |
| 2361 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2362 | else throw testing::TestError::Failed; |
| 2363 | } |
| 2364 | } |
| 2365 | |
| 2366 | /// The root of an owned derivation cannot be read or moved afterward. |
| 2367 | @test unsafe fn testOwnedRootUseAfterDerivationRejected() throws (testing::TestError) { |
| 2368 | for program in [ |
| 2369 | "fn f(s: *mut [u32]) -> u32 { let a: *mut u32 = &mut s[0]; return s[1]; }", |
| 2370 | "fn f(s: *mut [u32]) -> u32 { let a: *mut u32 = &mut s[0]; return s.len; }", |
| 2371 | "fn eat(s: *mut [u32]) {} fn f(s: *mut [u32]) { let a: *mut u32 = &mut s[0]; eat(s); }", |
| 2372 | "fn f(s: *mut [u32]) -> *mut [u32] { let a: *mut u32 = &mut s[0]; return s; }", |
| 2373 | "fn f(s: *mut [u32], flag: bool) { if flag { let a: *mut u32 = &mut s[0]; } set s[0] = 1; }", |
| 2374 | "record G { e: *mut [u32], n: u32 } fn f(g: G) -> u32 { let v: *[u32] = &g.e[..g.n]; return g.e.len; }", |
| 2375 | "record G { e: *mut [u32] } fn f(p: *mut G) -> u32 { let x: *mut [u32] = &mut p.e[..]; return p.e.len; }", |
| 2376 | ] { |
| 2377 | let mut res = testResolver(); |
| 2378 | let result = try resolveProgramStr(&mut res, program); |
| 2379 | let err = try expectError(&result); |
| 2380 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2381 | else throw testing::TestError::Failed; |
| 2382 | } |
| 2383 | } |
| 2384 | |
| 2385 | /// An owned derivation in a loop body moves the root on the next iteration. |
| 2386 | @test unsafe fn testOwnedRootDerivationInLoopRejected() throws (testing::TestError) { |
| 2387 | for program in [ |
| 2388 | "fn f(s: *mut [u32]) { let mut i: u32 = 0; while i < 2 { let a: *mut u32 = &mut s[0]; set i += 1; } }", |
| 2389 | ] { |
| 2390 | let mut res = testResolver(); |
| 2391 | let result = try resolveProgramStr(&mut res, program); |
| 2392 | let err = try expectError(&result); |
| 2393 | let case resolver::ErrorKind::LinearBranchMismatch(_) = err.kind |
| 2394 | else throw testing::TestError::Failed; |
| 2395 | } |
| 2396 | } |
| 2397 | |
| 2398 | /// A reference into an owned root excludes conflicting uses of the root while it is live. |
| 2399 | @test unsafe fn testOwnedRootReferenceConflictRejected() throws (testing::TestError) { |
| 2400 | for program in [ |
| 2401 | "fn f(s: *mut [u32]) { let r: &mut u32 = &mut s[0]; set s[0] = 1; set *r = 2; }", |
| 2402 | "fn f(s: *mut [u32]) { let r: &mut u32 = &mut s[0]; let q: &mut u32 = &mut s[0]; set *r = 2; set *q = 3; }", |
| 2403 | "fn f(s: *mut [u32]) -> *mut [u32] { let r: &mut u32 = &mut s[0]; let t = s; set *r = 2; return t; }", |
| 2404 | "fn f(s: *mut [u32]) -> u32 { let r: &mut u32 = &mut s[0]; let n = s[1]; set *r = 2; return n; }", |
| 2405 | "fn f(s: *mut [u32]) -> u32 { let r: &[u32] = &s[..]; set s[0] = 1; return r[0]; }", |
| 2406 | "record G { e: *mut [u32], n: u32 } fn f(g: G) { let r: &mut u32 = &mut g.e[0]; set g.e[1] = 1; set *r = 2; }", |
| 2407 | "record G { e: *mut [u32] } fn f(p: *mut G) { let r: &mut u32 = &mut p.e[0]; set p.e[1] = 1; set *r = 2; }", |
| 2408 | ] { |
| 2409 | let mut res = testResolver(); |
| 2410 | let result = try resolveProgramStr(&mut res, program); |
| 2411 | let err = try expectError(&result); |
| 2412 | let case resolver::ErrorKind::BorrowConflict(_) = err.kind |
| 2413 | else throw testing::TestError::Failed; |
| 2414 | } |
| 2415 | } |
| 2416 | |
| 2417 | /// Reference borrows of an owned root leave it usable once the borrow ends. |
| 2418 | @test unsafe fn testOwnedRootReferenceBorrowAllowed() throws (testing::TestError) { |
| 2419 | for program in [ |
| 2420 | "fn f(s: *mut [u32]) -> u32 { { let r: &mut u32 = &mut s[0]; set *r = 1; } set s[1] = 2; return s[0]; }", |
| 2421 | "fn f(s: *mut [u32]) -> u32 { let mut n: u32 = 0; { let r: &[u32] = &s[..]; set n = r[0]; } set s[0] = n; return s[0]; }", |
| 2422 | "fn bump(p: &mut u32) { set *p += 1; } fn f(s: *mut [u32]) { bump(&mut s[0]); bump(&mut s[0]); set s[1] = 0; }", |
| 2423 | "fn f(s: *mut [u32]) -> *mut [u32] { { let r: &mut [u32] = &mut s[..]; set r[0] = 1; } return s; }", |
| 2424 | "record G { e: *mut [u32], n: u32 } fn f() -> u32 { let mut g = G { e: &mut [], n: 0 }; { let r: &mut u32 = &mut g.e[0]; set *r = 1; } set g.n = 2; return g.e[0]; }", |
| 2425 | "record G { e: *mut [u32] } fn f(p: *mut G) -> u32 { let mut n: u32 = 0; { let r: &[u32] = &p.e[..]; set n = r[0]; } set p.e[1] = n; return p.e[1]; }", |
| 2426 | ] { |
| 2427 | let mut res = testResolver(); |
| 2428 | let result = try resolveProgramStr(&mut res, program); |
| 2429 | try expectNoErrors(&result); |
| 2430 | } |
| 2431 | } |
| 2432 | |
| 2433 | /// Deriving from an immutable owned root copies it, so the root stays usable. |
| 2434 | @test unsafe fn testImmutableOwnedRootDerivationAllowed() throws (testing::TestError) { |
| 2435 | for program in [ |
| 2436 | "fn f(s: *[u32]) -> u32 { let a: *u32 = &s[0]; let b: *u32 = &s[0]; return *a + *b + s[1]; }", |
| 2437 | "fn f(s: *[u32]) -> *[u32] { let a: *[u32] = &s[..]; let b: *[u32] = &s[1..]; return a; }", |
| 2438 | "record G { e: *[u32], n: u32 } fn f(g: G) -> u32 { let a: *[u32] = &g.e[..g.n]; let b: *[u32] = &g.e[..]; return g.n + a[0] + b[0]; }", |
| 2439 | "record G { e: *[u32] } fn f(p: *mut G) -> *[u32] { let a: *[u32] = &p.e[..]; let b: *[u32] = &p.e[..]; set p.e = b; return a; }", |
| 2440 | ] { |
| 2441 | let mut res = testResolver(); |
| 2442 | let result = try resolveProgramStr(&mut res, program); |
| 2443 | try expectNoErrors(&result); |
| 2444 | } |
| 2445 | } |
| 2446 | |
| 2447 | /// Unsafe code may derive several owned pointers from one owned root. |
| 2448 | @test unsafe fn testUnsafeOwnedRootDerivationAllowed() throws (testing::TestError) { |
| 2449 | for program in [ |
| 2450 | "fn f(s: *mut [u32]) { unsafe { let a: *mut u32 = &mut s[0]; let b: *mut u32 = &mut s[0]; } set s[0] = 1; }", |
| 2451 | "unsafe fn f(s: *mut [u32]) -> u32 { let v: *[u32] = &s[..]; set s[0] = 3; return v[0]; }", |
| 2452 | "record G { e: *mut [u32] } unsafe fn f(p: *mut G) { let x: *mut [u32] = &mut p.e[..]; let y: *mut [u32] = &mut p.e[..]; }", |
| 2453 | "record G { e: *mut [u32], n: u32 } fn f(g: G) -> u32 { unsafe { let v: *[u32] = &g.e[..g.n]; set g.e[0] = 1; } return g.n; }", |
| 2454 | ] { |
| 2455 | let mut res = testResolver(); |
| 2456 | let result = try resolveProgramStr(&mut res, program); |
| 2457 | try expectNoErrors(&result); |
| 2458 | } |
| 2459 | } |
| 2460 | |
| 2461 | /// Owned derivations from different first-level fields of an owned root are independent. |
| 2462 | @test unsafe fn testOwnedRootFieldDerivationsAllowed() throws (testing::TestError) { |
| 2463 | for program in [ |
| 2464 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut [u32] = &mut s.b[..]; }", |
| 2465 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut u8 = &mut s.a[3]; let y: *mut u32 = &mut s.b[1]; }", |
| 2466 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut (*s).a[..]; let y: *mut [u32] = &mut (*s).b[..]; }", |
| 2467 | "record I { v: [u8; 4] } record S { a: I, b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a.v[..]; let y: *mut [u32] = &mut s.b[..]; }", |
| 2468 | "record G { e: *mut [u32], f: *mut [u32] } fn f(g: G) { let x: *mut [u32] = &mut g.e[..]; let y: *mut [u32] = &mut g.f[..]; }", |
| 2469 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S, c: bool) { if c { let x: *mut [u8] = &mut s.a[..]; } else { let y: *mut [u32] = &mut s.b[..]; } }", |
| 2470 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S, c: bool) { let x: *mut [u8] = &mut s.a[..]; if c { let y: *mut [u32] = &mut s.b[..]; } }", |
| 2471 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> *mut [u32] { let x: *mut [u8] = &mut s.a[..]; return &mut s.b[..]; }", |
| 2472 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { loop { let x: *mut [u8] = &mut s.a[..]; break; } let y: *mut [u32] = &mut s.b[..]; }", |
| 2473 | "record G { e: *mut [u32], n: u32 } fn f() -> u32 { let mut g = G { e: &mut [], n: 0 }; let v: *[u32] = &g.e[..g.n]; set g.n = 1; return g.n; }", |
| 2474 | "record G { e: *mut [u32], n: u32 } fn f(g: G) -> u32 { let v: *[u32] = &g.e[..g.n]; return g.n; }", |
| 2475 | ] { |
| 2476 | let mut res = testResolver(); |
| 2477 | let result = try resolveProgramStr(&mut res, program); |
| 2478 | try expectNoErrors(&result); |
| 2479 | } |
| 2480 | } |
| 2481 | |
| 2482 | /// After a field derivation, the other fields can be read, written, and borrowed. |
| 2483 | @test unsafe fn testOwnedRootFieldDerivationOtherFieldsUsable() throws (testing::TestError) { |
| 2484 | for program in [ |
| 2485 | "record S { a: [u8; 16], b: [u32; 4], n: u32 } fn f(s: *mut S) -> u32 { let x: *mut [u8] = &mut s.a[..]; set s.n = 1; set s.b[0] = 2; return s.n + s.b[0]; }", |
| 2486 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let r: &mut u32 = &mut s.b[0]; set *r = 1; }", |
| 2487 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let r: &mut u32 = &mut s.b[0]; let x: *mut [u8] = &mut s.a[..]; set *r = 1; }", |
| 2488 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> u32 { let x: *mut [u8] = &mut s.a[..]; let r: &[u32] = &s.b[..]; return r[0]; }", |
| 2489 | "record S { a: [u8; 16], b: [u32; 4] } fn bump(p: &mut u32) { set *p += 1; } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; bump(&mut s.b[0]); }", |
| 2490 | ] { |
| 2491 | let mut res = testResolver(); |
| 2492 | let result = try resolveProgramStr(&mut res, program); |
| 2493 | try expectNoErrors(&result); |
| 2494 | } |
| 2495 | } |
| 2496 | |
| 2497 | /// A field cannot be derived or used again after a derivation moved it. |
| 2498 | @test unsafe fn testOwnedRootMovedFieldUseRejected() throws (testing::TestError) { |
| 2499 | for program in [ |
| 2500 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut [u8] = &mut s.a[..]; }", |
| 2501 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut u8 = &mut s.a[0]; }", |
| 2502 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut [u8] = &mut (*s).a[..]; }", |
| 2503 | "record I { v: [u8; 4] } record S { a: I, b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a.v[..]; let y: *mut [u8] = &mut s.a.v[..]; }", |
| 2504 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> u8 { let x: *mut [u8] = &mut s.a[..]; return s.a[0]; }", |
| 2505 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> u32 { let x: *mut [u8] = &mut s.a[..]; return s.a.len; }", |
| 2506 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; set s.a[0] = 1; }", |
| 2507 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let r: &mut u8 = &mut s.a[0]; set *r = 1; }", |
| 2508 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let r: &[u8] = &s.a[..]; }", |
| 2509 | "record G { e: *mut [u32], f: *mut [u32] } fn f(g: G) { let x: *mut [u32] = &mut g.e[..]; let y: *mut [u32] = &mut g.e[..]; }", |
| 2510 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S, c: bool) { if c { let x: *mut [u8] = &mut s.a[..]; } let y: *mut [u8] = &mut s.a[..]; }", |
| 2511 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S, c: bool) { if c { let x: *mut [u8] = &mut s.a[..]; } else { let y: *mut [u32] = &mut s.b[..]; } let z: *mut [u8] = &mut s.a[..]; }", |
| 2512 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { loop { let x: *mut [u8] = &mut s.a[..]; break; } let y: *mut [u8] = &mut s.a[..]; }", |
| 2513 | ] { |
| 2514 | let mut res = testResolver(); |
| 2515 | let result = try resolveProgramStr(&mut res, program); |
| 2516 | let err = try expectError(&result); |
| 2517 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2518 | else throw testing::TestError::Failed; |
| 2519 | } |
| 2520 | } |
| 2521 | |
| 2522 | /// A field derivation takes the field, so the whole root cannot be used afterward. |
| 2523 | @test unsafe fn testOwnedRootWholeUseAfterFieldDerivationRejected() throws (testing::TestError) { |
| 2524 | for program in [ |
| 2525 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn eat(p: *mut S) {} fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; eat(s); }", |
| 2526 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> S { let x: *mut [u8] = &mut s.a[..]; return *s; }", |
| 2527 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let r: &S = &*s; }", |
| 2528 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let r = &s; }", |
| 2529 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) -> *mut S { let x: *mut [u8] = &mut s.a[..]; return s; }", |
| 2530 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut S = &mut *s; }", |
| 2531 | "record S: Copy { a: [u8; 16], b: [u32; 4] } fn (s: *mut S) get() -> u8 { return s.a[0]; } fn f(s: *mut S) { let x: *mut [u32] = &mut s.b[..]; s.get(); }", |
| 2532 | "record G { e: *mut [u32], n: u32 } fn eat(g: G) {} fn f(g: G) { let x: *mut [u32] = &mut g.e[..]; eat(g); }", |
| 2533 | ] { |
| 2534 | let mut res = testResolver(); |
| 2535 | let result = try resolveProgramStr(&mut res, program); |
| 2536 | let err = try expectError(&result); |
| 2537 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2538 | else throw testing::TestError::Failed; |
| 2539 | } |
| 2540 | } |
| 2541 | |
| 2542 | /// Assigning the whole root after a field derivation makes every field available again. |
| 2543 | @test unsafe fn testOwnedRootFieldDerivationReinitialized() throws (testing::TestError) { |
| 2544 | for program in [ |
| 2545 | "record S { a: [u8; 16], b: [u32; 4] } fn f(p: *mut S, q: *mut S) { let mut s: *mut S = p; let x: *mut [u8] = &mut s.a[..]; set s = q; let y: *mut [u8] = &mut s.a[..]; }", |
| 2546 | "record G { e: *mut [u32], f: *mut [u32] } fn f(h: G) { let mut g: G = h; let x: *mut [u32] = &mut g.e[..]; set g = G { e: &mut [], f: &mut [] }; let y: *mut [u32] = &mut g.e[..]; }", |
| 2547 | ] { |
| 2548 | let mut res = testResolver(); |
| 2549 | let result = try resolveProgramStr(&mut res, program); |
| 2550 | try expectNoErrors(&result); |
| 2551 | } |
| 2552 | } |
| 2553 | |
| 2554 | /// A field derivation inside a loop moves the field again on the next iteration. |
| 2555 | @test unsafe fn testOwnedRootFieldDerivationInLoopRejected() throws (testing::TestError) { |
| 2556 | for program in [ |
| 2557 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let mut i: u32 = 0; while i < 2 { let a: *mut [u8] = &mut s.a[..]; set i += 1; } }", |
| 2558 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S, c: bool) { while c { if c { let a: *mut [u8] = &mut s.a[..]; break; } } }", |
| 2559 | ] { |
| 2560 | let mut res = testResolver(); |
| 2561 | let result = try resolveProgramStr(&mut res, program); |
| 2562 | let err = try expectError(&result); |
| 2563 | let case resolver::ErrorKind::LinearBranchMismatch(_) = err.kind |
| 2564 | else throw testing::TestError::Failed; |
| 2565 | } |
| 2566 | } |
| 2567 | |
| 2568 | /// A path that does not start with a field of the root still moves the whole root. |
| 2569 | @test unsafe fn testOwnedRootNonFieldPathMovesWholeRoot() throws (testing::TestError) { |
| 2570 | for program in [ |
| 2571 | "record P { x: u32, y: u32 } fn f(p: *mut [P]) -> u32 { let a: *mut u32 = &mut p[0].x; return p[1].y; }", |
| 2572 | "record P { x: u32, y: u32 } fn f(p: *mut [P]) { let a: *mut u32 = &mut p[0].x; let b: *mut u32 = &mut p[1].y; }", |
| 2573 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let q: *mut S = &mut *s; let x: *mut [u8] = &mut s.a[..]; }", |
| 2574 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let q: *mut S = &mut *s; let y: *mut [u32] = &mut s.b[..]; }", |
| 2575 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let q: *mut S = &mut *s; }", |
| 2576 | ] { |
| 2577 | let mut res = testResolver(); |
| 2578 | let result = try resolveProgramStr(&mut res, program); |
| 2579 | let err = try expectError(&result); |
| 2580 | let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind |
| 2581 | else throw testing::TestError::Failed; |
| 2582 | } |
| 2583 | } |
| 2584 | |
| 2585 | /// Owned mutable storage reached through a copyable immutable owned pointer |
| 2586 | /// cannot be derived from at all: the storage is immutable through that |
| 2587 | /// pointer, and two copies of it would otherwise give aliasing owned handles. |
| 2588 | @test unsafe fn testOwnedRootThroughImmutablePointerRejected() throws (testing::TestError) { |
| 2589 | for program in [ |
| 2590 | "record R { q: *mut [u32] } fn f(p: *R) { let a: *mut u32 = &mut p.q[0]; let b: *mut u32 = &mut p.q[0]; }", |
| 2591 | "record R { q: *mut [u32] } fn f(p: *R) { let c: *R = p; let a: *mut u32 = &mut p.q[0]; let b: *mut u32 = &mut c.q[0]; }", |
| 2592 | ] { |
| 2593 | let mut res = testResolver(); |
| 2594 | let result = try resolveProgramStr(&mut res, program); |
| 2595 | try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 2596 | } |
| 2597 | } |
| 2598 | |
| 2599 | /// Mutability is inherited along an access path. Storage reached through an |
| 2600 | /// immutable owned pointer, slice, or reference is immutable, even when the |
| 2601 | /// pointer stored there is mutable. |
| 2602 | @test unsafe fn testMutationThroughImmutablePointerRejected() throws (testing::TestError) { |
| 2603 | for program in [ |
| 2604 | "record R { q: *mut [u32] } fn f(p: *R) { set p.q[0] = 1; }", |
| 2605 | "record R { q: *mut [u32] } fn f(p: &R) { set p.q[0] = 1; }", |
| 2606 | "record R { q: *mut [u32] } fn f(p: *R) { let r: &mut u32 = &mut p.q[0]; }", |
| 2607 | "record R { q: *mut [u32] } fn f(p: *R) { set p.q[0..2] = 0; }", |
| 2608 | "record S { x: u32 } record R { s: *mut S } fn f(p: *R) { set p.s.x = 1; }", |
| 2609 | "record S { x: u32 } record R { s: *mut S } fn f(p: &R) { let r: &mut u32 = &mut p.s.x; }", |
| 2610 | "record S { x: u32 } record R { s: *mut S } fn f(p: *R) { set *p.s = S { x: 1 }; }", |
| 2611 | "record S { x: u32 } record R { s: *mut S } fn f(rs: *[R]) { set rs[0].s.x = 1; }", |
| 2612 | "record S { x: u32 } record R { s: *mut S } record T { r: R } fn f(t: *T) { set t.r.s.x = 1; }", |
| 2613 | "record S { x: u32 } fn (s: &mut S) bump() { set s.x += 1; } record M { s: S } record R { m: *mut M } fn f(p: *R) { p.m.s.bump(); }", |
| 2614 | "trait B { fn (&mut B) bump(); } record R { b: *mut opaque B } fn f(p: *R) { p.b.bump(); }", |
| 2615 | "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record S { v: *mut [u32] } record R { s: *mut S } fn f(p: *R, a: &Heap) { try! p.s.v.append(1, a); }", |
| 2616 | "record R { q: *mut [u32] } fn g(s: &mut [u32]) {} fn f(p: &R) { g(p.q); }", |
| 2617 | "record S { x: u32 } record R { s: *mut S } fn g(s: &mut S) {} fn f(rs: *[R]) { g(rs[0].s); }", |
| 2618 | "trait B { fn (&mut B) bump(); } record R { b: *mut opaque B } fn g(b: &mut opaque B) {} fn f(p: *R) { g(p.b); }", |
| 2619 | "record R { q: *mut [u32] } record T { x: u32 } fn (t: &T) put(s: &mut [u32]) {} fn f(t: &T, p: &R) { t.put(p.q); }", |
| 2620 | "trait P { fn (&P) put(s: &mut [u32]); } record R { q: *mut [u32] } fn f(t: &opaque P, p: &R) { t.put(p.q); }", |
| 2621 | "record R { q: *mut [u32] } fn g(s: &mut [u32]) {} fn f(p: &R) { let h = g; h(p.q); }", |
| 2622 | "union U { A(u32), B } record H { u: *mut U } fn f(h: &H) { match h.u { case U::A(x) => { set *x = 1; } else => {} } }", |
| 2623 | "union U { A(u32), B } record H { u: *mut U } fn f(h: &H) { if let case U::A(x) = h.u { set *x = 1; } }", |
| 2624 | "union U { A(u32), B } record H { u: *mut U } fn f(h: &H) { while let case U::A(x) = h.u { set *x = 1; return; } }", |
| 2625 | "union U { A(u32), B } record H { u: *mut U } fn f(h: &H) { let case U::A(x) = h.u else return; set *x = 1; }", |
| 2626 | "union U { A(u32), B } record H { u: *mut ?u32 } fn f(h: &H) { match h.u { x => { set *x = 1; } case nil => {} } }", |
| 2627 | ] { |
| 2628 | let mut res = testResolver(); |
| 2629 | let result = try resolveProgramStr(&mut res, program); |
| 2630 | try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 2631 | } |
| 2632 | } |
| 2633 | |
| 2634 | /// A mutation behind an immutable pointer is reported at that pointer, which is |
| 2635 | /// the one to make mutable. |
| 2636 | @test unsafe fn testImmutablePointerReportedAtPointer() throws (testing::TestError) { |
| 2637 | { |
| 2638 | let mut a = testResolver(); |
| 2639 | let program = "record S { x: u32 } record R { s: *mut S } fn f(p: *R) { set p.s.x = 1; }"; |
| 2640 | let result = try resolveProgramStr(&mut a, program); |
| 2641 | let err = try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 2642 | let errNode = err.node else throw testing::TestError::Failed; |
| 2643 | let case ast::NodeValue::Ident(_) = errNode.value else throw testing::TestError::Failed; |
| 2644 | } |
| 2645 | { |
| 2646 | let mut a = testResolver(); |
| 2647 | let program = "record S { x: u32 } record R { s: *S } fn f(p: *mut R) { set p.s.x = 1; }"; |
| 2648 | let result = try resolveProgramStr(&mut a, program); |
| 2649 | let err = try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer); |
| 2650 | let errNode = err.node else throw testing::TestError::Failed; |
| 2651 | let case ast::NodeValue::FieldAccess(_) = errNode.value |
| 2652 | else throw testing::TestError::Failed; |
| 2653 | } |
| 2654 | } |
| 2655 | |
| 2656 | /// Storage reached only through mutable pointers can be mutated, whatever the |
| 2657 | /// mutability of the binding that holds the first pointer. An unsafe pointer |
| 2658 | /// can be copied out of any place, so only its own mutability counts. |
| 2659 | @test unsafe fn testMutationThroughMutablePointerAllowed() throws (testing::TestError) { |
| 2660 | for program in [ |
| 2661 | "record S { x: u32 } record R { s: *mut S } fn f(p: *mut R) { set p.s.x = 1; }", |
| 2662 | "record S { x: u32 } record R { s: *mut S } fn f(p: &mut R) { set p.s.x = 1; }", |
| 2663 | "record S { x: u32 } record R { s: *mut S } fn f(r: R) { set r.s.x = 1; }", |
| 2664 | "record R { q: *mut [u32] } fn f(rs: *mut [R]) { set rs[0].q[1] = 1; }", |
| 2665 | "record S { x: u32 } fn (s: &mut S) bump() { set s.x += 1; } record M { s: S } record R { m: *mut M } fn f(p: *mut R) { p.m.s.bump(); }", |
| 2666 | "trait B { fn (&mut B) bump(); } record R { b: *mut opaque B } fn f(p: *mut R) { p.b.bump(); }", |
| 2667 | "record R { u: *unsafe mut u32 } fn f(p: *R) { unsafe { set *p.u = 1; } }", |
| 2668 | "record R { q: *mut [u32] } fn g(s: &mut [u32]) {} fn f(p: *mut R) { g(p.q); }", |
| 2669 | "record R { q: *mut [u32] } fn g(s: &mut [u32]) {} fn f(r: R) { g(r.q); }", |
| 2670 | "fn g(s: &mut [u32]) {} fn f(q: *mut [u32]) { g(q); }", |
| 2671 | "fn g(s: &mut [u32]) {} fn f(q: &mut [u32]) { g(q); }", |
| 2672 | "fn g(s: &mut [u32]) {} fn f() { let mut a: [u32; 2] = [1, 2]; g(&mut a[..]); }", |
| 2673 | "record R { u: *unsafe mut [u32] } fn g(s: &mut [u32]) {} fn f(p: *R) { unsafe { g(p.u); } }", |
| 2674 | "union U { A(u32), B } record H { u: *mut U } fn f(h: *mut H) { match h.u { case U::A(x) => { set *x = 1; } else => {} } }", |
| 2675 | "union U { A(u32), B } record H { u: *mut U } fn f(h: &H) -> u32 { match h.u { case U::A(x) => return *x, else => return 0 } }", |
| 2676 | ] { |
| 2677 | let mut res = testResolver(); |
| 2678 | let result = try resolveProgramStr(&mut res, program); |
| 2679 | try expectNoErrors(&result); |
| 2680 | } |
| 2681 | } |
| 2682 | |
| 2683 | /// Unsafe code may derive repeatedly from one field, and immutable owned roots never move. |
| 2684 | @test unsafe fn testOwnedRootFieldDerivationUnsafeAndImmutableAllowed() |
| 2685 | throws (testing::TestError) |
| 2686 | { |
| 2687 | for program in [ |
| 2688 | "record S { a: [u8; 16], b: [u32; 4] } fn f(s: *mut S) { unsafe { let x: *mut [u8] = &mut s.a[..]; let y: *mut [u8] = &mut s.a[..]; } set s.a[0] = 1; }", |
| 2689 | "record S { a: [u8; 16], b: [u32; 4] } unsafe fn f(s: *mut S) { let x: *mut [u8] = &mut s.a[..]; let y: *mut [u8] = &mut s.a[..]; }", |
| 2690 | "record S { a: *[u8], b: *[u32] } fn f(s: *mut S) -> u8 { let x: *[u8] = &s.a[..]; let y: *[u8] = &s.a[..]; return s.a[0] + x[0] + y[0]; }", |
| 2691 | ] { |
| 2692 | let mut res = testResolver(); |
| 2693 | let result = try resolveProgramStr(&mut res, program); |
| 2694 | try expectNoErrors(&result); |
| 2695 | } |
| 2696 | } |
| 2697 | |
| 2698 | // --- Definite initialization of `undefined` locals --- |
| 2699 | // |
| 2700 | // Only types that are not bit-valid are tracked. The tests use `bool`, which |
| 2701 | // has invalid bit patterns. |
| 2702 | |
| 2703 | /// Require a program to be rejected with a use of the uninitialized variable `x`. |
| 2704 | unsafe fn expectUninitialized(program: *[u8]) throws (testing::TestError) { |
| 2705 | let mut a = testResolver(); |
| 2706 | let result = try resolveProgramStr(&mut a, program); |
| 2707 | try expectErrorKind(&result, resolver::ErrorKind::UninitializedUse("x")); |
| 2708 | } |
| 2709 | |
| 2710 | /// A local initialized with `undefined` is safe once every path assigns it before a read. |
| 2711 | @test unsafe fn testUndefinedLocalAssignedBeforeUse() throws (testing::TestError) { |
| 2712 | let programs = &[ |
| 2713 | "fn run() -> bool { let mut x: bool = undefined; set x = true; return x; }", |
| 2714 | "fn run() { let x: bool = undefined; }", |
| 2715 | "fn run() -> bool { let mut x: bool = undefined; set x = true; set x = not x; return x; }", |
| 2716 | "record P: Copy { a: bool, b: bool } fn run() -> bool { let mut x: P = undefined; set x = P { a: true, b: false }; set x.a = false; return x.a or x.b; }", |
| 2717 | "fn run() -> bool { let mut x: [bool; 2] = undefined; set x = [true, false]; set x[0] = false; return x[0] or x[1]; }", |
| 2718 | "fn run() -> u32 { let mut x: ?u32 = undefined; set x = nil; let y = x else return 0; return y; }", |
| 2719 | "fn put(out: &mut bool) { set *out = true; } fn run() -> bool { let mut x: bool = undefined; set x = false; put(&mut x); return x; }", |
| 2720 | "record C: Copy { n: bool } fn (c: &C) get() -> bool { return c.n; } fn run() -> bool { let mut x: C = undefined; set x = C { n: true }; return x.get(); }", |
| 2721 | "fn run(n: bool) -> bool { let mut x: bool = undefined; set x = n; while x { set x = false; } return x; }", |
| 2722 | ]; |
| 2723 | for program in programs { |
| 2724 | try expectAnalyzeOk(program); |
| 2725 | } |
| 2726 | } |
| 2727 | |
| 2728 | /// Unsafe code keeps its own control over `undefined` locals. |
| 2729 | @test unsafe fn testUndefinedLocalUnsafeContextUntracked() throws (testing::TestError) { |
| 2730 | let programs = &[ |
| 2731 | "unsafe fn run() -> bool { let mut x: bool = undefined; return x; }", |
| 2732 | "fn run() -> bool { unsafe { let mut x: bool = undefined; return x; } }", |
| 2733 | "fn fill(out: &mut bool) { set *out = true; } fn run() -> bool { unsafe { let mut x: bool = undefined; fill(&mut x); return x; } }", |
| 2734 | ]; |
| 2735 | for program in programs { |
| 2736 | try expectAnalyzeOk(program); |
| 2737 | } |
| 2738 | } |
| 2739 | |
| 2740 | /// Both branches of a conditional must assign the variable. |
| 2741 | @test unsafe fn testUndefinedLocalAssignedOnEveryPath() throws (testing::TestError) { |
| 2742 | let programs = &[ |
| 2743 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c { set x = true; } else { set x = false; } return x; }", |
| 2744 | "fn run(c: bool) -> bool { let mut x: bool = undefined; set x = false if c else true; return x; }", |
| 2745 | "fn run(c: bool, d: bool) -> bool { let mut x: bool = undefined; if c { if d { set x = true; } else { set x = false; } } else { set x = true; } return x; }", |
| 2746 | "union K { A, B, C } fn run(k: K) -> bool { let mut x: bool = undefined; match k { case K::A => { set x = true; } case K::B => { set x = false; } case K::C => { set x = true; } } return x; }", |
| 2747 | "union K { A, B } fn run(k: K) -> bool { let mut x: bool = undefined; match k { case K::A => { set x = true; } else => { set x = false; } } return x; }", |
| 2748 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; if let v = o { set x = v; } else { set x = false; } return x; }", |
| 2749 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; let v = o else { set x = false; return x; }; set x = v; return x; }", |
| 2750 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; let v = o else { return false; }; set x = v; return x; }", |
| 2751 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c and true { set x = true; } else { set x = false; } return x; }", |
| 2752 | ]; |
| 2753 | for program in programs { |
| 2754 | try expectAnalyzeOk(program); |
| 2755 | } |
| 2756 | } |
| 2757 | |
| 2758 | /// A path that leaves the function or loop does not reach the join. |
| 2759 | @test unsafe fn testUndefinedLocalDivergingPaths() throws (testing::TestError) { |
| 2760 | let programs = &[ |
| 2761 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c { return false; } else { set x = true; } return x; }", |
| 2762 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c { set x = true; } else { panic \"stop\"; } return x; }", |
| 2763 | "union E { Fail } fn run(c: bool) -> bool throws (E) { let mut x: bool = undefined; if c { throw E::Fail; } set x = true; return x; }", |
| 2764 | "union E { Fail } fn f() -> bool throws (E) { throw E::Fail; } fn run() -> bool { let mut x: bool = undefined; set x = try f() catch { return false; }; return x; }", |
| 2765 | "fn run(n: u32) -> bool { let mut x: bool = undefined; let mut i: u32 = 0; loop { if i < n { set i += 1; continue; } set x = true; break; } return x; }", |
| 2766 | ]; |
| 2767 | for program in programs { |
| 2768 | try expectAnalyzeOk(program); |
| 2769 | } |
| 2770 | } |
| 2771 | |
| 2772 | /// A `loop` initializes the variable when every `break` follows an assignment. |
| 2773 | @test unsafe fn testUndefinedLocalAssignedInLoop() throws (testing::TestError) { |
| 2774 | let programs = &[ |
| 2775 | "fn run() -> bool { let mut x: bool = undefined; loop { set x = true; break; } return x; }", |
| 2776 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { if c { set x = true; break; } set x = false; break; } return x; }", |
| 2777 | "fn run(n: u32) -> bool { let mut x: bool = undefined; let mut i: u32 = 0; loop { set x = i > 0; if i >= n { break; } set i += 1; } return x; }", |
| 2778 | "fn run(n: bool) -> bool { let mut x: bool = undefined; set x = n; while x { let mut y: bool = undefined; set y = x; set x = not y; } return x; }", |
| 2779 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { loop { set x = true; break; } if c { break; } } return x; }", |
| 2780 | ]; |
| 2781 | for program in programs { |
| 2782 | try expectAnalyzeOk(program); |
| 2783 | } |
| 2784 | } |
| 2785 | |
| 2786 | /// Reuse of a binding slot does not inherit the state of a variable that left scope. |
| 2787 | @test unsafe fn testUndefinedLocalScopeSlotReused() throws (testing::TestError) { |
| 2788 | let programs = &[ |
| 2789 | "record R { n: u32 } fn take(r: R) {} fn run(c: bool) { if c { let mut x: bool = undefined; } let r = R { n: 1 }; take(r); }", |
| 2790 | "record R { n: u32 } fn take(r: R) {} fn run() { { let mut x: bool = undefined; } { let r = R { n: 1 }; take(r); } }", |
| 2791 | ]; |
| 2792 | for program in programs { |
| 2793 | try expectAnalyzeOk(program); |
| 2794 | } |
| 2795 | } |
| 2796 | |
| 2797 | /// An immutable binding cannot be assigned, so deferred initialization needs `mut`. |
| 2798 | @test unsafe fn testUndefinedImmutableLocalNotAssignable() throws (testing::TestError) { |
| 2799 | let mut a = testResolver(); |
| 2800 | let result = try resolveProgramStr( |
| 2801 | &mut a, "fn run() -> bool { let x: bool = undefined; set x = true; return x; }" |
| 2802 | ); |
| 2803 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding); |
| 2804 | } |
| 2805 | |
| 2806 | /// Every read of a variable that no assignment has reached is rejected. |
| 2807 | @test unsafe fn testUndefinedLocalReadBeforeAssignment() throws (testing::TestError) { |
| 2808 | let programs = &[ |
| 2809 | "fn run() -> bool { let mut x: bool = undefined; return x; }", |
| 2810 | "fn run() -> bool { let x: bool = undefined; let y = x; return y; }", |
| 2811 | "fn run() -> bool { let mut x: bool = undefined; return not x; }", |
| 2812 | "fn run() -> bool { let mut x: bool = undefined; return x == true; }", |
| 2813 | "fn run() { let mut x: bool = undefined; set x = not x; }", |
| 2814 | "fn take(b: bool) {} fn run() { let mut x: bool = undefined; take(x); }", |
| 2815 | "fn run() -> u32 { let mut x: bool = undefined; if x { return 1; } return 0; }", |
| 2816 | "record P: Copy { a: bool, b: bool } fn run() -> bool { let mut x: P = undefined; return x.a; }", |
| 2817 | "fn run() -> bool { let mut x: [bool; 2] = undefined; return x[1]; }", |
| 2818 | "fn run() -> bool { let mut x: [bool; 2] = undefined; let s = &x[0..1]; return s[0]; }", |
| 2819 | "record R { n: bool } fn take(r: R) {} fn run() { let mut x: R = undefined; take(x); }", |
| 2820 | "union K { A, B } fn run() -> u32 { let mut x: K = undefined; match x { case K::A => { return 1; } case K::B => { return 2; } } }", |
| 2821 | "fn run() -> u32 { let mut x: ?u32 = undefined; if let v = x { return v; } return 0; }", |
| 2822 | "fn run() -> u32 { let mut x: ?u32 = undefined; let v = x else return 0; return v; }", |
| 2823 | "fn run() -> bool { let mut x: bool = undefined; let mut y: bool = undefined; set y = true; return x or y; }", |
| 2824 | "fn run() -> bool { let mut x: bool = undefined; unsafe { return x; } }", |
| 2825 | ]; |
| 2826 | for program in programs { |
| 2827 | try expectUninitialized(program); |
| 2828 | } |
| 2829 | } |
| 2830 | |
| 2831 | /// Taking the address of a variable that no assignment has reached is a read. |
| 2832 | @test unsafe fn testUndefinedLocalAddressBeforeAssignment() throws (testing::TestError) { |
| 2833 | let programs = &[ |
| 2834 | "fn run() { let x: bool = undefined; let p = &x; }", |
| 2835 | "fn put(out: &mut bool) { set *out = true; } fn run() -> bool { let mut x: bool = undefined; put(&mut x); return x; }", |
| 2836 | "fn read(src: &bool) -> bool { return *src; } fn run() -> bool { let mut x: bool = undefined; return read(&x); }", |
| 2837 | "record C: Copy { n: bool } fn (c: &C) get() -> bool { return c.n; } fn run() -> bool { let mut x: C = undefined; return x.get(); }", |
| 2838 | "record C: Copy { n: bool } fn (c: &mut C) put() { set c.n = true; } fn run() { let mut x: C = undefined; x.put(); }", |
| 2839 | "fn run() -> bool { let mut x: [bool; 2] = undefined; let p = &mut x[..]; return p[0]; }", |
| 2840 | ]; |
| 2841 | for program in programs { |
| 2842 | try expectUninitialized(program); |
| 2843 | } |
| 2844 | } |
| 2845 | |
| 2846 | /// A field or element write needs the address of the variable and does not initialize it. |
| 2847 | @test unsafe fn testUndefinedLocalPartialWriteRejected() throws (testing::TestError) { |
| 2848 | let programs = &[ |
| 2849 | "record P: Copy { a: bool, b: bool } fn run() { let mut x: P = undefined; set x.a = true; }", |
| 2850 | "record P: Copy { a: bool, b: bool } fn run() -> bool { let mut x: P = undefined; set x.a = true; set x.b = false; return x.a; }", |
| 2851 | "fn run() { let mut x: [bool; 2] = undefined; set x[0] = true; }", |
| 2852 | "fn run() -> bool { let mut x: [bool; 2] = undefined; set x[0] = true; set x[1] = false; return x[0]; }", |
| 2853 | "fn run(p: *mut u32) { let mut x: *mut u32 = undefined; set *x = 1; }", |
| 2854 | ]; |
| 2855 | for program in programs { |
| 2856 | try expectUninitialized(program); |
| 2857 | } |
| 2858 | } |
| 2859 | |
| 2860 | /// A join initializes the variable only when every live path assigns it. |
| 2861 | @test unsafe fn testUndefinedLocalAssignedOnOnePathRejected() throws (testing::TestError) { |
| 2862 | let programs = &[ |
| 2863 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c { set x = true; } return x; }", |
| 2864 | "fn run(c: bool) -> bool { let mut x: bool = undefined; if c { } else { set x = true; } return x; }", |
| 2865 | "fn run(c: bool, d: bool) -> bool { let mut x: bool = undefined; if c { if d { set x = true; } } else { set x = false; } return x; }", |
| 2866 | "union K { A, B, C } fn run(k: K) -> bool { let mut x: bool = undefined; match k { case K::A => { set x = true; } case K::B => { set x = false; } case K::C => {} } return x; }", |
| 2867 | "union K { A, B } fn run(k: K) -> bool { let mut x: bool = undefined; match k { case K::A => { set x = true; } else => {} } return x; }", |
| 2868 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; if let v = o { set x = v; } return x; }", |
| 2869 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; while let v = o { set x = v; break; } return x; }", |
| 2870 | "fn run(o: ?bool) -> bool { let mut x: bool = undefined; if let v = o { set x = v; } else { } return x; }", |
| 2871 | "union E { Fail } fn f() throws (E) { throw E::Fail; } fn run() -> bool { let mut x: bool = undefined; try f() catch { set x = true; }; return x; }", |
| 2872 | "fn run(c: bool) -> bool { let mut x: bool = undefined; set x = true if c else x; return x; }", |
| 2873 | ]; |
| 2874 | for program in programs { |
| 2875 | try expectUninitialized(program); |
| 2876 | } |
| 2877 | } |
| 2878 | |
| 2879 | /// Assignments in a loop body that may run zero times do not initialize the variable. |
| 2880 | @test unsafe fn testUndefinedLocalAssignedInLoopBodyRejected() throws (testing::TestError) { |
| 2881 | let programs = &[ |
| 2882 | "fn run(c: bool) -> bool { let mut x: bool = undefined; while c { set x = true; } return x; }", |
| 2883 | "fn run(c: bool) -> bool { let mut x: bool = undefined; while c { set x = true; break; } return x; }", |
| 2884 | "fn run() -> bool { let mut x: bool = undefined; for i in 0..3 { set x = i > 0; } return x; }", |
| 2885 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { if c { break; } set x = true; } return x; }", |
| 2886 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { if c { set x = true; continue; } break; } return x; }", |
| 2887 | "fn run(c: bool) -> bool { let mut x: bool = undefined; while c { if x { break; } set x = true; } return false; }", |
| 2888 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { loop { if c { break; } set x = true; break; } break; } return x; }", |
| 2889 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { if c { set x = true; } else { break; } } return x; }", |
| 2890 | "fn run(c: bool) -> bool { let mut x: bool = undefined; loop { if c { break; } else { set x = true; break; } } return x; }", |
| 2891 | ]; |
| 2892 | for program in programs { |
| 2893 | try expectUninitialized(program); |
| 2894 | } |
| 2895 | } |
| 2896 | |
| 2897 | /// Pointers to arrays can be written in types, indexed, sliced, and passed on. |
| 2898 | @test unsafe fn testArrayPointerTypesAllowed() throws (testing::TestError) { |
| 2899 | for program in [ |
| 2900 | "fn f(p: *[u8; 4]) -> u8 { return p[0]; }", |
| 2901 | "fn f(p: *mut [u8; 4]) { set p[1] = 7; }", |
| 2902 | "fn f(p: &[u8; 4]) -> u8 { return p[3]; }", |
| 2903 | "fn f(p: &mut [u8; 4]) { set p[3] = 1; }", |
| 2904 | "unsafe fn f(p: *unsafe [u8; 4]) -> u8 { return p[0]; }", |
| 2905 | "unsafe fn f(p: *unsafe mut [u8; 4]) { set p[0] = 1; }", |
| 2906 | "fn f(p: &[u8; 4]) -> u32 { return p.len; }", |
| 2907 | "fn g(p: &mut [u8; 4]) {} fn f() { let mut a: [u8; 4] = [0; 4]; g(&mut a); }", |
| 2908 | "fn g(p: *mut [u32; 8]) {} fn f(p: *mut [u32; 8]) { g(p); }", |
| 2909 | "fn f(p: *mut [[u8; 2]; 3]) { set p[2][1] = 1; }", |
| 2910 | "record R { a: u8, b: u32 } fn f(p: *mut [R; 2]) { set p[1].b = 1; }", |
| 2911 | "fn f(p: *mut [u8; 4]) -> *mut [u8] { return &mut p[..]; }", |
| 2912 | "fn f(p: *mut [u8; 4]) -> *mut u8 { return &mut p[1]; }", |
| 2913 | "fn f(p: &mut [u8; 4]) { let s = &mut p[..]; set s[0] = 1; }", |
| 2914 | "fn f(p: &[u8; 4]) -> u32 { let s = &p[1..3]; return s.len; }", |
| 2915 | ] { |
| 2916 | let mut res = testResolver(); |
| 2917 | let result = try resolveProgramStr(&mut res, program); |
| 2918 | try expectNoErrors(&result); |
| 2919 | } |
| 2920 | } |
| 2921 | |
| 2922 | /// Pointers to arrays keep their length and mutability in type checking. |
| 2923 | @test unsafe fn testArrayPointerTypesRejected() throws (testing::TestError) { |
| 2924 | for program in [ |
| 2925 | "fn f(p: *[u8; 4]) { set p[0] = 1; }", |
| 2926 | "fn f(p: &[u8; 4]) { set p[0] = 1; }", |
| 2927 | "fn f(p: *mut [u8; 4]) -> *mut [u8; 5] { return p; }", |
| 2928 | "fn f(p: *mut [u8; 4]) -> *mut [u16; 4] { return p; }", |
| 2929 | "fn f(p: *mut [u8; 4]) -> u8 { return p[0] + p; }", |
| 2930 | "fn f(p: &[u8; 4]) -> *mut [u8] { return &mut p[..]; }", |
| 2931 | "fn f(p: *mut [u8; 4]) { let s = &mut p[..]; set p[0] = 1; }", |
| 2932 | "fn f(p: *mut [u8; 4]) { let a: *mut [u8] = &mut p[..]; let b: *mut [u8] = &mut p[..]; }", |
| 2933 | "fn f(p: *mut [u8; 4]) { let a: *mut [u8] = &mut p[..]; set p[0] = 1; }", |
| 2934 | ] { |
| 2935 | let mut res = testResolver(); |
| 2936 | let result = try resolveProgramStr(&mut res, program); |
| 2937 | try expectError(&result); |
| 2938 | } |
| 2939 | } |
| 2940 | |
| 2941 | // --- Immutable statics --- |
| 2942 | |
| 2943 | /// Safe code cannot assign to a static or to a place inside one. |
| 2944 | @test unsafe fn testStaticMutationRejected() throws (testing::TestError) { |
| 2945 | for program in [ |
| 2946 | "static V: u32 = 0; fn f() { set V = 1; }", |
| 2947 | "static V: u32 = 0; fn f() { set V += 1; }", |
| 2948 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { set V.x = 1; }", |
| 2949 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { set V = R { x: 1 }; }", |
| 2950 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { set V.x += 1; }", |
| 2951 | "record I { y: u32 } record R { i: I } static V: R = R { i: I { y: 0 } }; fn f() { set V.i.y = 1; }", |
| 2952 | "static A: [u32; 2] = [0; 2]; fn f() { set A[0] = 1; }", |
| 2953 | "static A: [u32; 2] = [0; 2]; fn f() { set A[1] += 1; }", |
| 2954 | "static A: [[u32; 2]; 2] = [[0; 2]; 2]; fn f() { set A[1][0] = 1; }", |
| 2955 | "static A: [u32; 4] = [0; 4]; fn f() { set A[1..3] = 7; }", |
| 2956 | "record R { a: [u32; 2] } static V: R = R { a: [0; 2] }; fn f() { set V.a[0] = 1; }", |
| 2957 | "fn f() { static V: u32 = 0; set V = 1; }", |
| 2958 | "static V: u32 = 0; fn f(n: u32) { for i in 0..n { set V = i; } }", |
| 2959 | "static V: u32 = 0; fn f() { let mut x: u32 = 1; set x = 2; set V = x; }", |
| 2960 | ] { |
| 2961 | let mut a = testResolver(); |
| 2962 | let result = try resolveProgramStr(&mut a, program); |
| 2963 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableStatic); |
| 2964 | } |
| 2965 | } |
| 2966 | |
| 2967 | /// A static reached through a module path is as immutable as one reached by name. |
| 2968 | @test unsafe fn testStaticModuleQualifiedMutationRejected() throws (testing::TestError) { |
| 2969 | for program in [ |
| 2970 | "use root::storage; fn f() { set storage::V = 1; }", |
| 2971 | "use root::storage; fn f() { set storage::A[0] = 1; }", |
| 2972 | "use root::storage; fn f() -> *mut u32 { return &mut storage::V; }", |
| 2973 | "use root::storage; fn f() -> *mut [u32] { return &mut storage::A[..]; }", |
| 2974 | "use root::storage::*; fn f() { set V = 1; }", |
| 2975 | "use root::storage::*; fn f() -> *mut [u32] { return &mut A[..]; }", |
| 2976 | ] { |
| 2977 | let mut a = testResolver(); |
| 2978 | let rootId = try registerModule( |
| 2979 | &mut super::MODULE_GRAPH, nil, "root", "export mod storage; mod app;" |
| 2980 | ); |
| 2981 | try registerModule( |
| 2982 | &mut super::MODULE_GRAPH, |
| 2983 | rootId, |
| 2984 | "storage", |
| 2985 | "export static V: u32 = 0; export static A: [u32; 2] = [0; 2];" |
| 2986 | ); |
| 2987 | try registerModule(&mut super::MODULE_GRAPH, rootId, "app", program); |
| 2988 | let result = try resolveModuleTree(&mut a, rootId); |
| 2989 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableStatic); |
| 2990 | } |
| 2991 | } |
| 2992 | |
| 2993 | /// Safe code cannot take a mutable address of a static or of a place inside |
| 2994 | /// one, whatever pointer class the address gets. |
| 2995 | @test unsafe fn testStaticMutableAddressRejected() throws (testing::TestError) { |
| 2996 | for program in [ |
| 2997 | "static V: u32 = 0; fn f() -> *mut u32 { return &mut V; }", |
| 2998 | "static V: u32 = 0; fn f() { let p: &mut u32 = &mut V; }", |
| 2999 | "static V: u32 = 0; fn f() { let p = &mut V; }", |
| 3000 | "static V: u32 = 0; fn g(p: &mut u32) {} fn f() { g(&mut V); }", |
| 3001 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { let p = &mut V.x; }", |
| 3002 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { let p = &mut V; }", |
| 3003 | "static A: [u32; 2] = [0; 2]; fn f() { let p = &mut A[0]; }", |
| 3004 | "static A: [u32; 2] = [0; 2]; fn f() { let p: &mut u32 = &mut A[1]; }", |
| 3005 | "static A: [u32; 2] = [0; 2]; fn f() -> *mut [u32] { return &mut A[..]; }", |
| 3006 | "static A: [u32; 2] = [0; 2]; fn f() { let s = &mut A[..]; }", |
| 3007 | "static A: [u32; 2] = [0; 2]; fn f() { let s: &mut [u32] = &mut A[..]; }", |
| 3008 | "static A: [u32; 4] = [0; 4]; fn f() { let s = &mut A[1..3]; }", |
| 3009 | "static A: [u32; 2] = [0; 2]; fn f() { let s = &mut A; }", |
| 3010 | "static B: [u8; 8] = [0; 8]; fn take(b: *mut [u8]) {} fn f() { take(&mut B[..]); }", |
| 3011 | "union U { A(u32), B } static V: U = U::B; fn f() { match &mut V { case U::A(n) => {}, else => {} } }", |
| 3012 | "union U { A(u32), B } static V: U = U::B; fn f() { if let case U::A(n) = &mut V {} }", |
| 3013 | "union U { A(u32), B } static V: U = U::B; fn f() { let r: &mut U = &mut V; match r { case U::A(n) => {}, else => {} } }", |
| 3014 | ] { |
| 3015 | let mut a = testResolver(); |
| 3016 | let result = try resolveProgramStr(&mut a, program); |
| 3017 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableStatic); |
| 3018 | } |
| 3019 | } |
| 3020 | |
| 3021 | /// Safe code cannot call a method that mutates its receiver on a static or on |
| 3022 | /// a place inside one. |
| 3023 | @test unsafe fn testStaticMutatingReceiverRejected() throws (testing::TestError) { |
| 3024 | for program in [ |
| 3025 | "record C { n: u32 } fn (c: &mut C) bump() { set c.n += 1; } static S: C = C { n: 0 }; fn f() { S.bump(); }", |
| 3026 | "record C { n: u32 } fn (c: &mut C) bump() { set c.n += 1; } record W { c: C } static S: W = W { c: C { n: 0 } }; fn f() { S.c.bump(); }", |
| 3027 | "record C { n: u32 } fn (c: &mut C) bump() { set c.n += 1; } static S: [C; 2] = [C { n: 0 }, C { n: 0 }]; fn f() { S[1].bump(); }", |
| 3028 | "record C { n: u32 } fn (c: &mut C) bump() { set c.n += 1; } fn f() { static S: C = C { n: 0 }; S.bump(); }", |
| 3029 | "record C { n: u32 } fn (c: *mut C) bump() { set c.n += 1; } static S: C = C { n: 0 }; fn f() { S.bump(); }", |
| 3030 | ] { |
| 3031 | let mut a = testResolver(); |
| 3032 | let result = try resolveProgramStr(&mut a, program); |
| 3033 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableStatic); |
| 3034 | } |
| 3035 | } |
| 3036 | |
| 3037 | /// Test that a mutable pointer in a static cannot be moved out by safe code, because every |
| 3038 | /// context can reach it. |
| 3039 | @test unsafe fn testStaticMutablePointerWriteRejected() throws (testing::TestError) { |
| 3040 | for program in [ |
| 3041 | "static P: ?*mut u32 = nil; fn f() -> ?*mut u32 { return P; }", |
| 3042 | "record H { p: ?*mut u32 } static V: H = H { p: nil }; fn f() { let p = V; }", |
| 3043 | ] { |
| 3044 | let mut a = testResolver(); |
| 3045 | let result = try resolveProgramStr(&mut a, program); |
| 3046 | try expectErrorKind(&result, resolver::ErrorKind::MoveOutOfStatic); |
| 3047 | } |
| 3048 | } |
| 3049 | |
| 3050 | /// Immutable pointers, unsafe pointers, and unsafe statics are still allowed |
| 3051 | /// in statics, and constants are not statics. |
| 3052 | @test unsafe fn testStaticMutablePointerAllowed() throws (testing::TestError) { |
| 3053 | for program in [ |
| 3054 | "static P: ?*u32 = nil;", |
| 3055 | "constant N: [*[u8]; 2] = [\"a\", \"b\"];", |
| 3056 | "unsafe static P: *mut [u32] = &mut [1, 2];", |
| 3057 | "record H { items: *mut [u32] } unsafe static V: H = H { items: &mut [] };", |
| 3058 | "unsafe fn f() -> *mut [u32] { unsafe static P: *mut [u32] = &mut [1]; return P; }", |
| 3059 | "constant P: *[u32] = &[1, 2];", |
| 3060 | ] { |
| 3061 | let mut a = testResolver(); |
| 3062 | let result = try resolveProgramStr(&mut a, program); |
| 3063 | try expectNoErrors(&result); |
| 3064 | } |
| 3065 | } |
| 3066 | |
| 3067 | /// Safe code cannot move a value out of a static, because the static would |
| 3068 | /// still hold it. |
| 3069 | @test unsafe fn testStaticMoveOutRejected() throws (testing::TestError) { |
| 3070 | for program in [ |
| 3071 | "record C { n: u32 } static S: C = C { n: 0 }; fn f() { let c = S; }", |
| 3072 | "record C { n: u32 } static S: C = C { n: 0 }; fn g(c: C) {} fn f() { g(S); }", |
| 3073 | "record C { n: u32 } static S: C = C { n: 0 }; fn f() -> C { return S; }", |
| 3074 | "record C { n: u32 } fn (c: *C) get() -> u32 { return c.n; } static S: C = C { n: 1 }; fn f() -> u32 { return S.get(); }", |
| 3075 | "union U { A(u32), B } static S: U = U::B; fn f() { match S { case U::A(n) => {}, else => {} } }", |
| 3076 | "union U { A(u32), B } static S: U = U::B; fn f() { if let case U::A(n) = S {} }", |
| 3077 | "union U { A(u32), B } fn f() { static S: U = U::B; let s = S; }", |
| 3078 | ] { |
| 3079 | let mut a = testResolver(); |
| 3080 | let result = try resolveProgramStr(&mut a, program); |
| 3081 | try expectErrorKind(&result, resolver::ErrorKind::MoveOutOfStatic); |
| 3082 | } |
| 3083 | } |
| 3084 | |
| 3085 | /// A static reached through a module path cannot be moved out of either. |
| 3086 | @test unsafe fn testStaticModuleQualifiedMoveOutRejected() throws (testing::TestError) { |
| 3087 | let mut a = testResolver(); |
| 3088 | let rootId = try registerModule( |
| 3089 | &mut super::MODULE_GRAPH, nil, "root", "export mod storage; mod app;" |
| 3090 | ); |
| 3091 | try registerModule( |
| 3092 | &mut super::MODULE_GRAPH, |
| 3093 | rootId, |
| 3094 | "storage", |
| 3095 | "export record C { n: u32 } export static S: C = C { n: 0 };" |
| 3096 | ); |
| 3097 | try registerModule( |
| 3098 | &mut super::MODULE_GRAPH, rootId, "app", "use root::storage; fn f() { let c = storage::S; }" |
| 3099 | ); |
| 3100 | let result = try resolveModuleTree(&mut a, rootId); |
| 3101 | try expectErrorKind(&result, resolver::ErrorKind::MoveOutOfStatic); |
| 3102 | } |
| 3103 | |
| 3104 | /// Reads, immutable addresses, and immutable owned views of a static stay |
| 3105 | /// allowed in safe code. |
| 3106 | @test unsafe fn testStaticReadsAllowed() throws (testing::TestError) { |
| 3107 | for program in [ |
| 3108 | "static V: u32 = 3; fn f() -> u32 { return V + 1; }", |
| 3109 | "record R { x: u32 } static V: R = R { x: 3 }; fn f() -> u32 { return V.x; }", |
| 3110 | "static A: [u32; 2] = [1, 2]; fn f() -> u32 { return A[1] + A.len; }", |
| 3111 | "static A: [u32; 4] = [1, 2, 3, 4]; fn f() -> u32 { let s = &A[1..3]; return s.len; }", |
| 3112 | "static V: u32 = 3; fn f() -> *u32 { return &V; }", |
| 3113 | "static V: u32 = 3; fn f() { let p: &u32 = &V; }", |
| 3114 | "static A: [u32; 2] = [1, 2]; fn f() -> *[u32] { return &A[..]; }", |
| 3115 | "static A: [u32; 2] = [1, 2]; fn f() { let s: &[u32] = &A[..]; let t = &A[0]; }", |
| 3116 | "record R { x: u32 } static V: R = R { x: 3 }; fn f() -> *u32 { return &V.x; }", |
| 3117 | "record R { x: u32 } static V: R = R { x: 3 }; fn f() -> *R { return &V; }", |
| 3118 | "static A: [u32; 2] = [1, 2]; fn f() -> u32 { let s = &A[..]; let t = &A[..]; return s[0] + t[1]; }", |
| 3119 | "record C { n: u32 } fn (c: &C) get() -> u32 { return c.n; } static S: C = C { n: 1 }; fn f() -> u32 { return S.get(); }", |
| 3120 | "static V: u32 = 3; fn f() -> u32 { let mut V: u32 = 1; set V = 2; return V; }", |
| 3121 | "static V: u32 = 3; fn f() -> u32 { let mut x = V; set x = 2; return x; }", |
| 3122 | "static A: [u32; 2] = [1, 2]; fn f() -> u32 { let mut a = A; set a[0] = 9; return a[0]; }", |
| 3123 | "record C: Copy { n: u32 } static S: C = C { n: 1 }; fn f() -> u32 { let mut c = S; set c.n = 2; return c.n + S.n; }", |
| 3124 | "static N: [[u8; 2]; 2] = [[0; 2]; 2]; fn f() { let a = N; }", |
| 3125 | "constant K: u32 = 3; fn f() -> u32 { return K; }", |
| 3126 | "static V: u32 = 3; fn g(p: *u32) -> u32 { return *p; } fn f() -> u32 { return g(&V); }", |
| 3127 | ] { |
| 3128 | let mut a = testResolver(); |
| 3129 | let result = try resolveProgramStr(&mut a, program); |
| 3130 | try expectNoErrors(&result); |
| 3131 | } |
| 3132 | } |
| 3133 | |
| 3134 | /// Unsafe blocks and functions can still mutate an ordinary static, take a |
| 3135 | /// mutable address of it, and move a value out of it. |
| 3136 | @test unsafe fn testStaticMutationInUnsafeAllowed() throws (testing::TestError) { |
| 3137 | for program in [ |
| 3138 | "static V: u32 = 0; fn f() { unsafe { set V = 1; } }", |
| 3139 | "static V: u32 = 0; unsafe fn f() { set V += 1; }", |
| 3140 | "record R { x: u32 } static V: R = R { x: 0 }; fn f() { unsafe { set V.x = 1; } }", |
| 3141 | "static A: [u32; 2] = [0; 2]; fn f() { unsafe { set A[0] = 1; set A[1] += 1; set A[0..2] = 3; } }", |
| 3142 | "static A: [u32; 2] = [0; 2]; fn f() { unsafe { let s: *mut [u32] = &mut A[..]; set s[0] = 1; } }", |
| 3143 | "static V: u32 = 0; unsafe fn f() -> *mut u32 { return &mut V; }", |
| 3144 | "record C { n: u32 } fn (c: &mut C) bump() { set c.n += 1; } static S: C = C { n: 0 }; fn f() { unsafe { S.bump(); } }", |
| 3145 | "record C { n: u32 } static S: C = C { n: 0 }; unsafe fn f() { let c = S; }", |
| 3146 | "union U { A(u32), B } static V: U = U::B; fn f() { unsafe { match &mut V { case U::A(n) => {}, else => {} } } }", |
| 3147 | "unsafe static V: u32 = 0; unsafe fn f() { set V = 1; }", |
| 3148 | "unsafe static A: [u32; 2] = [0; 2]; fn f() { unsafe { set A[0] = 1; } }", |
| 3149 | "unsafe static P: *mut [u32] = &mut [1, 2]; fn f() { unsafe { set P[0] = 5; } }", |
| 3150 | ] { |
| 3151 | let mut a = testResolver(); |
| 3152 | let result = try resolveProgramStr(&mut a, program); |
| 3153 | try expectNoErrors(&result); |
| 3154 | } |
| 3155 | } |
| 3156 | |
| 3157 | /// An unsafe static keeps its rule: any access needs an unsafe context, and a |
| 3158 | /// mutation outside one reports that, not an immutable static. |
| 3159 | @test unsafe fn testUnsafeStaticStillRequiresUnsafe() throws (testing::TestError) { |
| 3160 | for program in [ |
| 3161 | "unsafe static V: u32 = 0; fn f() { set V = 1; }", |
| 3162 | "unsafe static A: [u32; 2] = [0; 2]; fn f() { set A[0] = 1; }", |
| 3163 | "unsafe static V: u32 = 0; fn f() -> *mut u32 { return &mut V; }", |
| 3164 | "unsafe static P: *mut [u32] = &mut [1, 2]; fn f() { set P[0] = 5; }", |
| 3165 | ] { |
| 3166 | let mut a = testResolver(); |
| 3167 | let result = try resolveProgramStr(&mut a, program); |
| 3168 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 3169 | } |
| 3170 | } |
| 3171 | |
| 3172 | /// A constant is immutable data, so it cannot hold an owned mutable pointer, |
| 3173 | /// slice, or trait object, in safe or unsafe code. |
| 3174 | @test unsafe fn testConstMutablePointerRejected() throws (testing::TestError) { |
| 3175 | for program in [ |
| 3176 | "constant C: *mut [u32] = &mut [1, 2];", |
| 3177 | "constant C: *mut [u32] = &mut [];", |
| 3178 | "constant C: *mut u32 = undefined;", |
| 3179 | "constant C: ?*mut [u32] = nil;", |
| 3180 | "constant C: [*mut [u32]; 2] = undefined;", |
| 3181 | "record H { items: *mut [u32] } constant C: H = H { items: &mut [] };", |
| 3182 | "union Slot { Ptr(*mut u32), Num(u64) } constant C: Slot = Slot::Num(0);", |
| 3183 | "trait T { fn (*mut T) m(); } constant C: *mut opaque T = undefined;", |
| 3184 | "fn f() { constant C: *mut [u32] = &mut [1]; }", |
| 3185 | "unsafe fn f() { constant C: *mut [u32] = &mut [1]; }", |
| 3186 | ] { |
| 3187 | let mut a = testResolver(); |
| 3188 | let result = try resolveProgramStr(&mut a, program); |
| 3189 | try expectErrorKind(&result, resolver::ErrorKind::ConstMutablePointer); |
| 3190 | } |
| 3191 | } |
| 3192 | |
| 3193 | /// A constant record or union variant written in place is read-only data, so |
| 3194 | /// its address is an owned pointer, as for a constant array literal. |
| 3195 | @test unsafe fn testAddressOfConstantLiteralOwned() throws (testing::TestError) { |
| 3196 | for program in [ |
| 3197 | "record R: Copy { a: i32 } fn f() -> *R { return &R { a: 1 }; }", |
| 3198 | "record P(i32, i32): Copy; fn f() -> *P { return &P(1, 2); }", |
| 3199 | "union V: Copy { One(i32), Nothing } fn f() -> *V { return &V::One(1); }", |
| 3200 | "union V: Copy { One(i32), Nothing } fn f() -> *V { return &V::Nothing; }", |
| 3201 | "union V: Copy { Rec { a: i32 }, Nothing } fn f() -> *V { return &V::Rec { a: 1 }; }", |
| 3202 | "record R: Copy { a: i32 } constant K: i32 = 3; fn f() -> *R { return &R { a: K }; }", |
| 3203 | "fn f() -> *[i32] { return &[1, 2]; }", |
| 3204 | ] { |
| 3205 | try expectAnalyzeOk(program); |
| 3206 | } |
| 3207 | } |
| 3208 | |
| 3209 | /// A value that is not constant, or that is mutable, is a temporary that only |
| 3210 | /// a reference can address. |
| 3211 | @test unsafe fn testAddressOfTemporaryNotOwned() throws (testing::TestError) { |
| 3212 | for program in [ |
| 3213 | "record R: Copy { a: i32 } fn f(x: i32) -> *R { return &R { a: x }; }", |
| 3214 | "record P(i32, i32): Copy; fn f(x: i32) -> *P { return &P(x, 2); }", |
| 3215 | "union V: Copy { One(i32), Nothing } fn f(x: i32) -> *V { return &V::One(x); }", |
| 3216 | "record R: Copy { a: i32 } fn f() -> *R { return &mut R { a: 1 }; }", |
| 3217 | "record R: Copy { a: i32 } fn f() -> *mut R { return &mut R { a: 1 }; }", |
| 3218 | "union V: Copy { One(i32), Nothing } fn f() -> *V { return &mut V::Nothing; }", |
| 3219 | "fn f(x: i32) -> *[i32] { return &[x, 2]; }", |
| 3220 | "fn f() -> *mut [i32] { return &mut [1, 2]; }", |
| 3221 | ] { |
| 3222 | let mut a = testResolver(); |
| 3223 | let result = try resolveProgramStr(&mut a, program); |
| 3224 | let err = try expectError(&result); |
| 3225 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind |
| 3226 | else throw testing::TestError::Failed; |
| 3227 | } |
| 3228 | } |
| 3229 | |
| 3230 | /// A temporary can be borrowed by a call, and a mutable one by a mutable |
| 3231 | /// reference parameter, but a local cannot keep the reference. |
| 3232 | @test unsafe fn testAddressOfTemporaryBorrow() throws (testing::TestError) { |
| 3233 | for program in [ |
| 3234 | "record R: Copy { a: i32 } fn g(r: &R) {} fn f(x: i32) { g(&R { a: x }); }", |
| 3235 | "record R: Copy { a: i32 } fn g(r: &mut R) {} fn f() { g(&mut R { a: 1 }); }", |
| 3236 | "union V: Copy { One(i32), Nothing } fn g(v: &mut V) {} fn f() { g(&mut V::One(1)); g(&mut V::Nothing); }", |
| 3237 | "record P(i32): Copy; fn g(p: &mut P) {} fn f() { g(&mut P(1)); }", |
| 3238 | ] { |
| 3239 | try expectAnalyzeOk(program); |
| 3240 | } |
| 3241 | for program in [ |
| 3242 | "record R: Copy { a: i32 } fn f(x: i32) { let r = &R { a: x }; }", |
| 3243 | "record R: Copy { a: i32 } fn f() { let r = &mut R { a: 1 }; }", |
| 3244 | ] { |
| 3245 | let mut a = testResolver(); |
| 3246 | let result = try resolveProgramStr(&mut a, program); |
| 3247 | try expectErrorKind(&result, resolver::ErrorKind::RefBinding); |
| 3248 | } |
| 3249 | } |
| 3250 | |
| 3251 | /// A linear value written in place and only borrowed is never consumed. |
| 3252 | @test unsafe fn testAddressOfLinearLiteralRejected() throws (testing::TestError) { |
| 3253 | for program in [ |
| 3254 | "union C: Once { Value(u32) } fn g(c: &C) {} fn f() { g(&C::Value(1)); }", |
| 3255 | "record M: Once {} fn g(m: &M) {} fn f() { g(&M {}); }", |
| 3256 | "record M: Once {} fn g(m: &mut M) {} fn f() { g(&mut M {}); }", |
| 3257 | "record M: Once {} fn g(m: &[M]) {} fn f() { g(&[M {}]); }", |
| 3258 | ] { |
| 3259 | let mut a = testResolver(); |
| 3260 | let result = try resolveProgramStr(&mut a, program); |
| 3261 | try expectErrorKind(&result, resolver::ErrorKind::LinearDiscard); |
| 3262 | } |
| 3263 | } |
| 3264 | |
| 3265 | /// The address of a call result, a computed value, a cast, or a field of a |
| 3266 | /// temporary is a reference to a temporary, and so is the mutable address. |
| 3267 | @test unsafe fn testAddressOfValueBorrow() throws (testing::TestError) { |
| 3268 | for program in [ |
| 3269 | "fn v() -> i32 { return 1; } fn g(r: &i32) {} fn f() { g(&v()); }", |
| 3270 | "fn v() -> i32 { return 1; } fn g(r: &mut i32) {} fn f() { g(&mut v()); }", |
| 3271 | "fn g(r: &i32) {} fn f(x: i32) { g(&(x + 1)); }", |
| 3272 | "fn g(r: &mut i32) {} fn f(x: i32) { g(&mut (x + 1)); }", |
| 3273 | "fn g(r: &u64) {} fn f(x: i32) { g(&(x as u64)); }", |
| 3274 | "fn g(r: &i32) {} fn f() { g(&(5 as i32)); }", |
| 3275 | "fn g(r: &bool) {} fn f(x: i32) { g(&(x == 1)); g(¬ (x == 2)); }", |
| 3276 | "fn g(r: &i32) {} fn f(x: i32, c: bool) { g(&(x if c else 0)); g(&-x); }", |
| 3277 | "fn g(r: &u32) {} fn f(a: [i32; 2]) { g(&a.len); }", |
| 3278 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn g(r: &R) {} fn f() { g(&v()); }", |
| 3279 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn g(r: &mut R) {} fn f() { g(&mut v()); }", |
| 3280 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn g(r: &mut i32) {} fn f() { g(&mut v().a); }", |
| 3281 | "fn v() -> [i32; 2] { return [1, 2]; } fn g(r: &mut i32) {} fn f() { g(&mut v()[1]); }", |
| 3282 | "fn v() -> [i32; 2] { return [1, 2]; } fn g(r: &[i32]) {} fn f() { g(&v()[..]); }", |
| 3283 | "fn v() -> i32 throws (u32) { return 1; } fn g(r: &i32) {} fn f() { g(&try! v()); }", |
| 3284 | "fn v() -> i32 throws (u32) { return 1; } fn g(r: &?i32) {} fn f() { g(&try? v()); }", |
| 3285 | "fn g(r: &*[u8]) {} fn f() { g(&\"abc\"); }", |
| 3286 | ] { |
| 3287 | try expectAnalyzeOk(program); |
| 3288 | } |
| 3289 | } |
| 3290 | |
| 3291 | /// A temporary has no storage after its expression, so its address is never an |
| 3292 | /// owned pointer. |
| 3293 | @test unsafe fn testAddressOfValueNotOwned() throws (testing::TestError) { |
| 3294 | for program in [ |
| 3295 | "fn v() -> i32 { return 1; } fn f() -> *i32 { return &v(); }", |
| 3296 | "fn v() -> i32 { return 1; } fn f() -> *mut i32 { return &mut v(); }", |
| 3297 | "fn f(x: i32) -> *i32 { return &(x + 1); }", |
| 3298 | "fn f() -> *i32 { return &(5 as i32); }", |
| 3299 | "fn f(x: i32) -> *u64 { return &(x as u64); }", |
| 3300 | "fn f(x: i32, c: bool) -> *i32 { return &(x if c else 0); }", |
| 3301 | "fn f(a: [i32; 2]) -> *u32 { return &a.len; }", |
| 3302 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn f() -> *R { return &v(); }", |
| 3303 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn f() -> *i32 { return &v().a; }", |
| 3304 | "fn v() -> [i32; 2] { return [1, 2]; } fn f() -> *i32 { return &v()[0]; }", |
| 3305 | ] { |
| 3306 | let mut a = testResolver(); |
| 3307 | let result = try resolveProgramStr(&mut a, program); |
| 3308 | let err = try expectError(&result); |
| 3309 | let case resolver::ErrorKind::TypeMismatch(_) = err.kind |
| 3310 | else throw testing::TestError::Failed; |
| 3311 | } |
| 3312 | } |
| 3313 | |
| 3314 | /// A local cannot keep a reference to a temporary. |
| 3315 | @test unsafe fn testAddressOfValueLocalRejected() throws (testing::TestError) { |
| 3316 | for program in [ |
| 3317 | "fn v() -> i32 { return 1; } fn f() { let r = &v(); }", |
| 3318 | "fn f(x: i32) { let r = &(x + 1); }", |
| 3319 | "fn f(x: i32) { let r = &mut (x + 1); }", |
| 3320 | "fn f(x: i32) { let r = &(x as u64); }", |
| 3321 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn f() { let r = &v().a; }", |
| 3322 | "record R: Copy { a: i32 } fn v() -> R { return R { a: 1 }; } fn f() { let r = &mut v(); }", |
| 3323 | ] { |
| 3324 | let mut a = testResolver(); |
| 3325 | let result = try resolveProgramStr(&mut a, program); |
| 3326 | try expectErrorKind(&result, resolver::ErrorKind::RefBinding); |
| 3327 | } |
| 3328 | } |
| 3329 | |
| 3330 | /// A linear result that is only borrowed is never consumed. The rest of a |
| 3331 | /// linear record is discarded when only a field is addressed. |
| 3332 | @test unsafe fn testAddressOfLinearValueRejected() throws (testing::TestError) { |
| 3333 | for program in [ |
| 3334 | "union C: Once { Value(u32) } fn v() -> C { return C::Value(1); } fn g(c: &C) {} fn f() { g(&v()); }", |
| 3335 | "union C: Once { Value(u32) } fn v() -> C { return C::Value(1); } fn g(c: &mut C) {} fn f() { g(&mut v()); }", |
| 3336 | "record M: Once { n: u32 } fn v() -> M { return M { n: 1 }; } fn g(n: &u32) {} fn f() { g(&v().n); }", |
| 3337 | "record M: Once { n: u32 } fn v() -> M { return M { n: 1 }; } fn g(n: &mut u32) {} fn f() { g(&mut v().n); }", |
| 3338 | "record M: Once { n: u32 } fn g(m: &M) {} fn f(c: bool, a: M, b: M) { g(&(a if c else b)); }", |
| 3339 | ] { |
| 3340 | let mut a = testResolver(); |
| 3341 | let result = try resolveProgramStr(&mut a, program); |
| 3342 | try expectErrorKind(&result, resolver::ErrorKind::LinearDiscard); |
| 3343 | } |
| 3344 | } |
| 3345 | |
| 3346 | /// A call that returns nothing has no value to address. |
| 3347 | @test unsafe fn testAddressOfVoidRejected() throws (testing::TestError) { |
| 3348 | for program in [ |
| 3349 | "fn v() {} fn g(p: &opaque) {} fn f() { g(&v()); }", |
| 3350 | "fn v() {} fn g(p: &mut opaque) {} fn f() { g(&mut v()); }", |
| 3351 | ] { |
| 3352 | let mut a = testResolver(); |
| 3353 | let result = try resolveProgramStr(&mut a, program); |
| 3354 | try expectErrorKind(&result, resolver::ErrorKind::VoidAddress); |
| 3355 | } |
| 3356 | } |
| 3357 | |
| 3358 | /// A place keeps its own storage class and mutability rules. |
| 3359 | @test unsafe fn testAddressOfPlaceUnchanged() throws (testing::TestError) { |
| 3360 | for program in [ |
| 3361 | "fn f(x: i32) { let r = &mut x; }", |
| 3362 | "record R: Copy { a: i32 } fn f(r: R) { let p = &mut r.a; }", |
| 3363 | "fn f(a: [i32; 2]) { let p = &mut a[0]; }", |
| 3364 | ] { |
| 3365 | let mut a = testResolver(); |
| 3366 | let result = try resolveProgramStr(&mut a, program); |
| 3367 | try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding); |
| 3368 | } |
| 3369 | } |
| 3370 | |
| 3371 | /// A method with an owned receiver cannot take the address of a local, because an owned |
| 3372 | /// pointer must not point into a frame. |
| 3373 | @test unsafe fn testResolveOwnedReceiverLocal() throws (testing::TestError) { |
| 3374 | let mut a = testResolver(); |
| 3375 | let program = |
| 3376 | "record C { v: i32 } fn (c: *mut C) bump() { set c.v = c.v + 1; } fn f() { let mut c = C { v: 1 }; c.bump(); }"; |
| 3377 | let result = try resolveProgramStr(&mut a, program); |
| 3378 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3379 | } |
| 3380 | |
| 3381 | /// An immutable owned receiver is rejected for a local too. |
| 3382 | @test unsafe fn testResolveOwnedReceiverImmutableLocal() throws (testing::TestError) { |
| 3383 | let mut a = testResolver(); |
| 3384 | let program = |
| 3385 | "record C { v: i32 } fn (c: *C) get() -> i32 { return c.v; } fn f() -> i32 { let c = C { v: 1 }; return c.get(); }"; |
| 3386 | let result = try resolveProgramStr(&mut a, program); |
| 3387 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3388 | } |
| 3389 | |
| 3390 | /// A by-value parameter and a field of one are frame storage. |
| 3391 | @test unsafe fn testResolveOwnedReceiverParameter() throws (testing::TestError) { |
| 3392 | let mut a = testResolver(); |
| 3393 | let program = |
| 3394 | "record C { v: i32 } record D { c: C } fn (c: *C) get() -> i32 { return c.v; } fn f(d: D) -> i32 { return d.c.get(); }"; |
| 3395 | let result = try resolveProgramStr(&mut a, program); |
| 3396 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3397 | } |
| 3398 | |
| 3399 | /// A reference cannot become an owned receiver, and neither can a place behind one. |
| 3400 | @test unsafe fn testResolveOwnedReceiverReference() throws (testing::TestError) { |
| 3401 | let mut a = testResolver(); |
| 3402 | let program = |
| 3403 | "record C { v: i32 } fn (c: *C) get() -> i32 { return c.v; } fn f(r: &C) -> i32 { return r.get(); }"; |
| 3404 | let result = try resolveProgramStr(&mut a, program); |
| 3405 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3406 | } |
| 3407 | |
| 3408 | /// A call result is a temporary, which an owned receiver cannot address. |
| 3409 | @test unsafe fn testResolveOwnedReceiverTemporary() throws (testing::TestError) { |
| 3410 | let mut a = testResolver(); |
| 3411 | let program = |
| 3412 | "record C { v: i32 } fn (c: *C) get() -> i32 { return c.v; } fn make() -> C { return C { v: 1 }; } fn f() -> i32 { return make().get(); }"; |
| 3413 | let result = try resolveProgramStr(&mut a, program); |
| 3414 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3415 | } |
| 3416 | |
| 3417 | /// A trait method with an owned receiver cannot be called through a reference to an object. |
| 3418 | @test unsafe fn testResolveOwnedReceiverTraitObject() throws (testing::TestError) { |
| 3419 | let mut a = testResolver(); |
| 3420 | let program = |
| 3421 | "record C { v: i32 } trait R { fn (*R) get() -> i32; } instance R for C { fn (c: *C) get() -> i32 { return c.v; } } fn f(r: &opaque R) -> i32 { return r.get(); }"; |
| 3422 | let result = try resolveProgramStr(&mut a, program); |
| 3423 | try expectErrorKind(&result, resolver::ErrorKind::ReceiverNotOwned); |
| 3424 | } |
| 3425 | |
| 3426 | /// An owned pointer is an owned receiver. |
| 3427 | @test unsafe fn testResolveOwnedReceiverThroughOwnedPointer() throws (testing::TestError) { |
| 3428 | let mut a = testResolver(); |
| 3429 | let program = |
| 3430 | "record C { v: i32 } fn (c: *mut C) bump() { set c.v = c.v + 1; } fn f(p: *mut C) { p.bump(); }"; |
| 3431 | let result = try resolveProgramStr(&mut a, program); |
| 3432 | try expectNoErrors(&result); |
| 3433 | } |
| 3434 | |
| 3435 | /// A reference receiver can address a local, by value or through a reference. |
| 3436 | @test unsafe fn testResolveReferenceReceiver() throws (testing::TestError) { |
| 3437 | let mut a = testResolver(); |
| 3438 | let program = |
| 3439 | "record C { v: i32 } fn (c: &mut C) bump() { set c.v = c.v + 1; } fn (c: &C) get() -> i32 { return c.v; } fn f() -> i32 { let mut c = C { v: 1 }; c.bump(); return c.get(); } fn g(r: &mut C) -> i32 { r.bump(); return r.get(); }"; |
| 3440 | let result = try resolveProgramStr(&mut a, program); |
| 3441 | try expectNoErrors(&result); |
| 3442 | } |
| 3443 | |
| 3444 | /// A catch statement cannot discard a successful exact-use return value. |
| 3445 | @test unsafe fn discardedCaughtOnceResult() throws (testing::TestError) { |
| 3446 | let mut res = testResolver(); |
| 3447 | let result = try resolveProgramStr( |
| 3448 | &mut res, |
| 3449 | "union Ticket: Once { New } fn make() -> Ticket throws(u32) { return Ticket::New; } fn run() { try make() catch {}; }" |
| 3450 | ); |
| 3451 | try expectErrorKind(&result, resolver::ErrorKind::LinearDiscard); |
| 3452 | } |