lib/std/lang/resolver/tests/safety.rad 191.8 KiB 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(&not (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
}