lib/std/lang/resolver/tests/structure.rad 188.8 KiB raw
1
//! Resolver tests: union and module declarations, imports, opaque pointers, match patterns, and
2
//! slice builtins.
3
4
use std::lang::ast;
5
use std::lang::module;
6
use std::lang::resolver;
7
use std::lang::resolver::tests::*;
8
use std::lang::types;
9
use std::mem;
10
use std::testing;
11
12
// Union tests /////////////////////////////////////////////////////////////////
13
14
@test unsafe fn testResolveUnionVariantWithoutPayload() throws (testing::TestError) {
15
    let mut a = testResolver();
16
    let program = "union Status { Ok, Error } Status::Ok;";
17
    let result = try resolveProgramStr(&mut a, program);
18
19
    let ty = try getTypeInScopeOf(&a, result.root, "Status");
20
    let case resolver::NominalType::Union(unionType) = a.nominals[*ty]
21
        else throw testing::TestError::Failed;
22
    try testing::expect(unionType.variants.len == 2);
23
    try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
24
    try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
25
    if getUnionVariantPayload(&a, ty, "Ok") <> resolver::Type::Void {
26
        throw testing::TestError::Failed;
27
    }
28
    let stmt = try getBlockStmt(result.root, 1);
29
    try expectExprStmtType(&a, stmt, resolver::Type::Nominal(ty));
30
    try expectNoErrors(&result);
31
}
32
33
@test unsafe fn testResolveUnionVariantWithPayload() throws (testing::TestError) {
34
    let mut a = testResolver();
35
    let program = "union R { Ok(i32), Err(bool) } R::Ok(42);";
36
    let result = try resolveProgramStr(&mut a, program);
37
    try expectNoErrors(&result);
38
39
    let ty = try getTypeInScopeOf(&a, result.root, "R");
40
41
    let okPayload = getUnionVariantPayload(&a, ty, "Ok");
42
    try testing::expect(okPayload == resolver::Type::I32);
43
44
    let errPayload = getUnionVariantPayload(&a, ty, "Err");
45
    try testing::expect(errPayload == resolver::Type::Bool);
46
47
    let stmt = try getBlockStmt(result.root, 1);
48
    try expectExprStmtType(&a, stmt, resolver::Type::Nominal(ty));
49
50
    // TODO: Test payload type.
51
}
52
53
@test unsafe fn testResolveUnionVariantWithoutPayloadExplicitDiscriminant()
54
    throws (testing::TestError)
55
{
56
    let mut a = testResolver();
57
    let program = "union R { Ok = 7, Err = 11 } R::Ok;";
58
    let result = try resolveProgramStr(&mut a, program);
59
    try expectNoErrors(&result);
60
61
    let ty = try getTypeInScopeOf(&a, result.root, "R");
62
    let stmt = try getBlockStmt(result.root, 1);
63
    try expectExprStmtType(&a, stmt, resolver::Type::Nominal(ty));
64
}
65
66
@test unsafe fn testResolveUnionDiscriminantRange() throws (testing::TestError) {
67
    let mut a = testResolver();
68
    let valid = try resolveProgramStr(&mut a, "union R { A = 255 } R::A;");
69
    try expectNoErrors(&valid);
70
    let mut b = testResolver();
71
    let explicit = try resolveProgramStr(&mut b, "union R { A = 256 } R::A;");
72
    try expectErrorKind(&explicit, resolver::ErrorKind::NumericLiteralOverflow);
73
    let mut c = testResolver();
74
    let implicit = try resolveProgramStr(&mut c, "union R { A = 255, B } R::B;");
75
    try expectErrorKind(&implicit, resolver::ErrorKind::NumericLiteralOverflow);
76
    let mut d = testResolver();
77
    let wide = try resolveProgramStr(&mut d, "union R { A = 4294967296 } R::A;");
78
    try expectErrorKind(&wide, resolver::ErrorKind::NumericLiteralOverflow);
79
}
80
81
/// Union variants must have distinct discriminants.
82
@test unsafe fn testResolveUnionDuplicateDiscriminants() throws (testing::TestError) {
83
    let programs = &[
84
        "union R { A(u64), B = 0 }",
85
        "union R { A = 2, B = 2 }",
86
        "union R { A = 2, B, C = 3 }",
87
    ];
88
    for program in programs {
89
        let mut a = testResolver();
90
        let result = try resolveProgramStr(&mut a, program);
91
        try expectError(&result);
92
    }
93
}
94
95
@test unsafe fn testResolveUnionVariantPayloadTypeMismatch() throws (testing::TestError) {
96
    let mut a = testResolver();
97
    let program = "union R { Ok(i32), Error(bool) } R::Ok(true);";
98
    let result = try resolveProgramStr(&mut a, program);
99
    let err = try expectError(&result);
100
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Bool);
101
102
    let ty = try getTypeInScopeOf(&a, result.root, "R");
103
    let payload = getUnionVariantPayload(&a, ty, "Ok");
104
    try testing::expect(payload == resolver::Type::I32);
105
106
    let errNode = err.node else throw testing::TestError::Failed;
107
    let case ast::NodeValue::Bool(_) = errNode.value else throw testing::TestError::Failed;
108
}
109
110
@test unsafe fn testResolveUnionVariantUnexpectedPayload() throws (testing::TestError) {
111
    let mut a = testResolver();
112
    let program = "union Status { Ok, Error } Status::Ok(42);";
113
    let result = try resolveProgramStr(&mut a, program);
114
    let err = try expectError(&result);
115
116
    let case resolver::ErrorKind::UnionVariantPayloadUnexpected(_) = err.kind
117
        else throw testing::TestError::Failed;
118
    let node = err.node else throw testing::TestError::Failed;
119
    let case ast::NodeValue::Call(_) = node.value else throw testing::TestError::Failed;
120
}
121
122
@test unsafe fn testResolveUnionVariantUnknown() throws (testing::TestError) {
123
    let mut a = testResolver();
124
    let program = "union Status { Ok, Error } Status::Unknown;";
125
    let result = try resolveProgramStr(&mut a, program);
126
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("Unknown"));
127
}
128
129
@test unsafe fn testResolveScopeAccessUndefinedType() throws (testing::TestError) {
130
    let mut a = testResolver();
131
    let result = try resolveProgramStr(&mut a, "Unknown::X;");
132
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("Unknown"));
133
}
134
135
@test unsafe fn testResolveUnionVariantVoidPayload() throws (testing::TestError) {
136
    let mut a = testResolver();
137
    let program = "union R { Success(i32), Pending } R::Pending;";
138
    let result = try resolveProgramStr(&mut a, program);
139
    try expectNoErrors(&result);
140
141
    let ty = try getTypeInScopeOf(&a, result.root, "R");
142
    let payload = getUnionVariantPayload(&a, ty, "Pending");
143
    try testing::expect(payload == resolver::Type::Void);
144
145
    let stmt = try getBlockStmt(result.root, 1);
146
    try expectExprStmtType(&a, stmt, resolver::Type::Nominal(ty));
147
}
148
149
@test unsafe fn testResolveUnionVariantRecordPayload() throws (testing::TestError) {
150
    let mut a = testResolver();
151
    let program =
152
        "record P { x: i32, y: i32 } union S { Point(P), Num(u32) } S::Point(P { x: 10, y: 20 });";
153
    let result = try resolveProgramStr(&mut a, program);
154
    try expectNoErrors(&result);
155
156
    let ty = try getTypeInScopeOf(&a, result.root, "S");
157
    let stmt = try getBlockStmt(result.root, 2);
158
    try expectExprStmtType(&a, stmt, resolver::Type::Nominal(ty));
159
}
160
161
@test unsafe fn testResolveBuiltinSizeOf() throws (testing::TestError) {
162
    try resolveAndExpectConstExpr("@sizeOf(u8)", 1);
163
    try resolveAndExpectConstExpr("@sizeOf(u16)", 2);
164
    try resolveAndExpectConstExpr("@sizeOf(u32)", 4);
165
    try resolveAndExpectConstExpr("@sizeOf(i32)", 4);
166
    try resolveAndExpectConstExpr("@sizeOf(bool)", 1);
167
    try resolveAndExpectConstExpr("@sizeOf(*u32)", 8);
168
    try resolveAndExpectConstExpr("@sizeOf([u8; 10])", 10);
169
    try resolveAndExpectConstExpr("@sizeOf(*[u32])", 16);
170
    try resolveAndExpectConstExpr("@sizeOf(?u8)", 2);
171
    try resolveAndExpectConstExpr("@sizeOf(?u16)", 4);
172
    try resolveAndExpectConstExpr("@sizeOf(?u32)", 8);
173
    try resolveAndExpectConstExpr("@sizeOf(*opaque)", 8);
174
    try resolveAndExpectConstStmt("record T { x: u8 } @sizeOf(T);", 1);
175
    try resolveAndExpectConstStmt("record T { x: i32 } @sizeOf(T);", 4);
176
    try resolveAndExpectConstStmt("record T { x: i32, y: i8 } @sizeOf(T);", 8);
177
    try resolveAndExpectConstStmt("record T { x: i8, y: i32 } @sizeOf(T);", 8);
178
    try resolveAndExpectConstStmt("record T { x: i8, y: i32 } @sizeOf(T);", 8);
179
    try resolveAndExpectConstStmt("record T { x: u32, y: u8, z: u8 }; @sizeOf(T);", 8);
180
    try resolveAndExpectConstStmt("record T { x: u8, y: u32, z: u8 }; @sizeOf(T);", 12);
181
    try resolveAndExpectConstStmt("union T { A, B, C }; @sizeOf(T);", 1);
182
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @sizeOf(T);", 8);
183
    try resolveAndExpectConstStmt("union T { A, B(u16), C }; @sizeOf(T);", 4);
184
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C(u16) }; @sizeOf(T);", 8);
185
    try resolveAndExpectConstStmt("union T { A(u32), B(u16), C([u8; 16]) }; @sizeOf(T);", 20);
186
}
187
188
@test unsafe fn testResolveBuiltinAlignOf() throws (testing::TestError) {
189
    try resolveAndExpectConstExpr("@alignOf(u8)", 1);
190
    try resolveAndExpectConstExpr("@alignOf(u16)", 2);
191
    try resolveAndExpectConstExpr("@alignOf(u32)", 4);
192
    try resolveAndExpectConstExpr("@alignOf(i32)", 4);
193
    try resolveAndExpectConstExpr("@alignOf(bool)", 1);
194
    try resolveAndExpectConstExpr("@alignOf(*u8)", 8);
195
    try resolveAndExpectConstExpr("@alignOf(*u16)", 8);
196
    try resolveAndExpectConstExpr("@alignOf(*u32)", 8);
197
    try resolveAndExpectConstExpr("@alignOf(*opaque)", 8);
198
    try resolveAndExpectConstExpr("@alignOf([u8; 8])", 1);
199
    try resolveAndExpectConstExpr("@alignOf([u16; 8])", 2);
200
    try resolveAndExpectConstExpr("@alignOf([u32; 8])", 4);
201
    try resolveAndExpectConstExpr("@alignOf(*[u32])", 8);
202
    try resolveAndExpectConstExpr("@alignOf(?u8)", 1);
203
    try resolveAndExpectConstExpr("@alignOf(?u16)", 2);
204
    try resolveAndExpectConstExpr("@alignOf(?u32)", 4);
205
    try resolveAndExpectConstStmt("record T { x: u8, y: u16 }; @alignOf(T);", 2);
206
    try resolveAndExpectConstStmt("record T { x: u8, y: u32, z: u8 }; @alignOf(T);", 4);
207
    try resolveAndExpectConstStmt("record T { x: u32, y: u8, z: u8 }; @alignOf(T);", 4);
208
    try resolveAndExpectConstStmt("union T { A, B, C }; @alignOf(T);", 1);
209
    try resolveAndExpectConstStmt("union T { A, B(u32), C }; @alignOf(T);", 4);
210
}
211
212
@test unsafe fn testResolveBuiltinSizeOfRecord() throws (testing::TestError) {
213
    let mut a = testResolver();
214
    let program = "record T { x: u8, y: u32 } @sizeOf(T);";
215
    let result = try resolveProgramStr(&mut a, program);
216
    try expectNoErrors(&result);
217
218
    let stmt = try getBlockStmt(result.root, 1);
219
    let expr = try expectExprStmtType(&a, stmt, resolver::Type::U32);
220
    try expectConstInt(&a, expr, 8);
221
}
222
223
@test unsafe fn testResolveBuiltinSizeOfUnion() throws (testing::TestError) {
224
    let mut a = testResolver();
225
    let program = "union Result { Ok(u32), Err(u8) } @sizeOf(Result);";
226
    let result = try resolveProgramStr(&mut a, program);
227
    try expectNoErrors(&result);
228
229
    let stmt = try getBlockStmt(result.root, 1);
230
    let expr = try expectExprStmtType(&a, stmt, resolver::Type::U32);
231
    try expectConstInt(&a, expr, 8);
232
}
233
234
@test unsafe fn testResolveAlignAnnotation() throws (testing::TestError) {
235
    {
236
        let mut a = testResolver();
237
        let result = try resolveBlockStr(&mut a, "let x: u8 align(8) = 0;");
238
        try expectNoErrors(&result);
239
240
        let stmt = try getBlockStmt(result.root, 0);
241
        let sym = resolver::symbolFor(&a, stmt) else throw testing::TestError::Failed;
242
        let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*sym].data
243
            else throw testing::TestError::Failed;
244
        let layout = resolver::getLayout(&a, a.symbols[*sym].node, valType);
245
        try testing::expect(layout.alignment == 8);
246
    }
247
    {
248
        let mut a = testResolver();
249
        let result = try resolveProgramStr(&mut a, "let x: u32 align(3) = 0;");
250
        let err = try expectError(&result);
251
        let case resolver::ErrorKind::InvalidAlignmentValue(val) = err.kind
252
            else throw testing::TestError::Failed;
253
        try testing::expect(val == 3);
254
    }
255
    {
256
        let mut a = testResolver();
257
        let result = try resolveProgramStr(&mut a, "let x: u32 align(7) = 0;");
258
        let err = try expectError(&result);
259
        let case resolver::ErrorKind::InvalidAlignmentValue(val) = err.kind
260
            else throw testing::TestError::Failed;
261
        try testing::expect(val == 7);
262
    }
263
}
264
265
@test unsafe fn testResolveVoidAssignmentError() throws (testing::TestError) {
266
    {
267
        let mut a = testResolver();
268
        let program = "fn voidFn() {} let _ = voidFn();";
269
        let result = try resolveProgramStr(&mut a, program);
270
        try expectErrorKind(&result, resolver::ErrorKind::CannotAssignVoid);
271
    }
272
    {
273
        let mut a = testResolver();
274
        let program = "fn voidFn() {} let x = voidFn();";
275
        let result = try resolveProgramStr(&mut a, program);
276
        try expectErrorKind(&result, resolver::ErrorKind::CannotAssignVoid);
277
    }
278
}
279
280
//
281
// Module Declaration Tests
282
//
283
284
@test unsafe fn testResolveEmptyMod() throws (testing::TestError) {
285
    let mut a = testResolver();
286
    let mut graph = &mut super::MODULE_GRAPH;
287
288
    let rootId = try registerModule(graph, nil, "root", "mod child;");
289
    let childId = try registerModule(graph, rootId, "child", "{}");
290
    let result = try resolveModuleTree(&mut a, rootId);
291
    try expectNoErrors(&result);
292
}
293
294
@test unsafe fn testResolveModuleCannotAccessParentScope() throws (testing::TestError) {
295
    let mut a = testResolver();
296
297
    // Register root and util modules.
298
    let rootId = try registerModule(
299
        &mut super::MODULE_GRAPH, nil, "root", "mod util; export fn helper() {}"
300
    );
301
    let utilId = try registerModule(
302
        &mut super::MODULE_GRAPH, rootId, "util", "fn main() { helper(); }"
303
    );
304
305
    // Resolve should fail: the parent module is not in scope.
306
    let result = try resolveModuleTree(&mut a, rootId);
307
    let err = try expectError(&result);
308
    let case resolver::ErrorKind::UnresolvedSymbol(name) = err.kind
309
        else throw testing::TestError::Failed;
310
    try testing::expect(mem::eq(name, "helper"));
311
}
312
313
@test unsafe fn testResolveModuleAccessPrivateSubModule() throws (testing::TestError) {
314
    let mut a = testResolver();
315
316
    // Register root and util modules.
317
    let rootId = try registerModule(
318
        &mut super::MODULE_GRAPH, nil, "root", "mod util; fn main() { util::helper(); }"
319
    );
320
    let utilId = try registerModule(
321
        &mut super::MODULE_GRAPH, rootId, "util", "export fn helper() {}"
322
    );
323
324
    // Resolve should succeed: parent can access child.
325
    let result = try resolveModuleTree(&mut a, rootId);
326
    try expectNoErrors(&result);
327
}
328
329
@test unsafe fn testResolveSiblingModulesCannotAccessDirectly() throws (testing::TestError) {
330
    let mut a = testResolver();
331
332
    // Register root with two sibling modules.
333
    let rootId = try registerModule(
334
        &mut super::MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;"
335
    );
336
    let appId = try registerModule(
337
        &mut super::MODULE_GRAPH, rootId, "paul", "fn main() { patrick::helper(); }"
338
    );
339
    let utilId = try registerModule(
340
        &mut super::MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }"
341
    );
342
343
    // Resolve should fail: siblings can't access each other directly.
344
    let result = try resolveModuleTree(&mut a, rootId);
345
    let err = try expectError(&result);
346
    let case resolver::ErrorKind::UnresolvedSymbol(name) = err.kind
347
        else throw testing::TestError::Failed;
348
    try testing::expect(mem::eq(name, "patrick"));
349
}
350
351
@test unsafe fn testResolveSiblingModulesViaRoot() throws (testing::TestError) {
352
    let mut a = testResolver();
353
354
    // Register root with two sibling modules.
355
    let rootId = try registerModule(
356
        &mut super::MODULE_GRAPH, nil, "root", "mod paul; export mod patrick;"
357
    );
358
    let appId = try registerModule(
359
        &mut super::MODULE_GRAPH,
360
        rootId,
361
        "paul",
362
        "use root::patrick; fn main() -> i32 { return patrick::helper(); }"
363
    );
364
    let utilId = try registerModule(
365
        &mut super::MODULE_GRAPH, rootId, "patrick", "export fn helper() -> i32 { return 42; }"
366
    );
367
368
    // Resolve should succeed: siblings can access each other via root.
369
    let result = try resolveModuleTree(&mut a, rootId);
370
    try expectNoErrors(&result);
371
}
372
373
@test unsafe fn testResolveModuleMutualRecursion() throws (testing::TestError) {
374
    let mut a = testResolver();
375
376
    // Register root with two sibling modules that call each other.
377
    let rootId = try registerModule(
378
        &mut super::MODULE_GRAPH, nil, "root", "export mod left; export mod right;"
379
    );
380
    let appId = try registerModule(
381
        &mut super::MODULE_GRAPH,
382
        rootId,
383
        "left",
384
        "use root::right; export fn leftHelper() -> i32 { return right::rightHelper(); }"
385
    );
386
    let utilId = try registerModule(
387
        &mut super::MODULE_GRAPH,
388
        rootId,
389
        "right",
390
        "use root::left; export fn rightHelper() -> i32 { return left::leftHelper(); }"
391
    );
392
393
    // Resolve should succeed: cyclic use is allowed.
394
    let result = try resolveModuleTree(&mut a, rootId);
395
    try expectNoErrors(&result);
396
}
397
398
@test unsafe fn testResolveAccessModuleType() throws (testing::TestError) {
399
    let mut a = testResolver();
400
401
    // Register root with types module containing a record.
402
    let rootId = try registerModule(
403
        &mut super::MODULE_GRAPH, nil, "root", "export mod types; mod app;"
404
    );
405
    let typesId = try registerModule(
406
        &mut super::MODULE_GRAPH, rootId, "types", "export record Point { x: i32, y: i32 }"
407
    );
408
    let appId = try registerModule(
409
        &mut super::MODULE_GRAPH,
410
        rootId,
411
        "app",
412
        "use root::types; fn main() -> i32 { let p = types::Point { x: 1, y: 2 }; return p.x; }"
413
    );
414
415
    // Resolve should succeed: types can be accessed.
416
    let result = try resolveModuleTree(&mut a, rootId);
417
    try expectNoErrors(&result);
418
}
419
420
@test unsafe fn testResolveAccessModuleConstant() throws (testing::TestError) {
421
    let mut a = testResolver();
422
423
    // Register root with constants module.
424
    let rootId = try registerModule(
425
        &mut super::MODULE_GRAPH, nil, "root", "export mod consts; mod app;"
426
    );
427
    let constantsId = try registerModule(
428
        &mut super::MODULE_GRAPH, rootId, "consts", "export constant MAX_SIZE: i32 = 100;"
429
    );
430
    let appId = try registerModule(
431
        &mut super::MODULE_GRAPH,
432
        rootId,
433
        "app",
434
        "use root::consts; fn main() -> i32 { return consts::MAX_SIZE; }"
435
    );
436
437
    // Resolve should succeed: constants can be accessed.
438
    let result = try resolveModuleTree(&mut a, rootId);
439
    try expectNoErrors(&result);
440
}
441
442
@test unsafe fn testResolveRootSymbolMustBeImported() throws (testing::TestError) {
443
    let mut a = testResolver();
444
445
    // Register deeply nested modules: `root::app::services::auth`.
446
    let rootId = try registerModule(
447
        &mut super::MODULE_GRAPH, nil, "root", "mod main; export fn helper() -> i32 { return 42; }"
448
    );
449
    let mainId = try registerModule(
450
        &mut super::MODULE_GRAPH, rootId, "main", "fn run() -> i32 { return root::helper(); }"
451
    );
452
453
    // Resolve should fail: the `root` module must be imported.
454
    let result = try resolveModuleTree(&mut a, rootId);
455
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("root"));
456
}
457
458
@test unsafe fn testResolveUseImportsNestedSymbol() throws (testing::TestError) {
459
    let mut a = testResolver();
460
461
    // Register deeply nested modules: `root::app::services::auth`.
462
    let rootId = try registerModule(
463
        &mut super::MODULE_GRAPH, nil, "root", "export mod app; mod main;"
464
    );
465
    let appId = try registerModule(&mut super::MODULE_GRAPH, rootId, "app", "export mod services;");
466
    let servicesId = try registerModule(
467
        &mut super::MODULE_GRAPH, appId, "services", "export mod auth;"
468
    );
469
    let authId = try registerModule(
470
        &mut super::MODULE_GRAPH, servicesId, "auth", "export fn login() -> i32 { return 1; }"
471
    );
472
    let mainId = try registerModule(
473
        &mut super::MODULE_GRAPH,
474
        rootId,
475
        "main",
476
        "use root::app::services::auth; fn run() -> i32 { return auth::login(); }"
477
    );
478
    let otherId = try registerModule(
479
        &mut super::MODULE_GRAPH,
480
        rootId,
481
        "other",
482
        "use root; fn run() -> i32 { return root::app::services::auth::login(); }"
483
    );
484
485
    // Resolve should succeed: use imports the module symbol.
486
    let result = try resolveModuleTree(&mut a, rootId);
487
    try expectNoErrors(&result);
488
}
489
490
@test unsafe fn testResolveUseNonExistentModule() throws (testing::TestError) {
491
    let mut a = testResolver();
492
493
    // Register root with app trying to use a non-existent module.
494
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod app;");
495
    let appId = try registerModule(&mut super::MODULE_GRAPH, rootId, "app", "use root::unknown;");
496
497
    // Resolve should fail: module doesn't exist.
498
    let result = try resolveModuleTree(&mut a, rootId);
499
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("unknown"));
500
}
501
502
@test unsafe fn testResolveUsePrivateFn() throws (testing::TestError) {
503
    let mut a = testResolver();
504
505
    // Register root with util module containing a private function.
506
    let rootId = try registerModule(
507
        &mut super::MODULE_GRAPH, nil, "root", "export mod util; mod app;"
508
    );
509
    let utilId = try registerModule(
510
        &mut super::MODULE_GRAPH, rootId, "util", "fn private() -> i32 { return 42; }"
511
    );
512
    let appId = try registerModule(
513
        &mut super::MODULE_GRAPH,
514
        rootId,
515
        "app",
516
        "use root::util; fn main() -> i32 { return util::private(); }"
517
    );
518
519
    // Resolve should fail: function is not public.
520
    let result = try resolveModuleTree(&mut a, rootId);
521
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("private"));
522
}
523
524
@test unsafe fn testResolveUsePrivateMod() throws (testing::TestError) {
525
    let mut a = testResolver();
526
527
    // Register root with public and private child modules.
528
    let rootId = try registerModule(
529
        &mut super::MODULE_GRAPH, nil, "root", "mod main; mod private;"
530
    );
531
    let privateId = try registerModule(&mut super::MODULE_GRAPH, rootId, "private", "{}");
532
    let publicId = try registerModule(
533
        &mut super::MODULE_GRAPH, rootId, "main", "use root::private;"
534
    );
535
536
    // Resolve should fail: module is not public.
537
    let result = try resolveModuleTree(&mut a, rootId);
538
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("private"));
539
}
540
541
@test unsafe fn testResolveUsePublicMod() throws (testing::TestError) {
542
    let mut a = testResolver();
543
544
    // Register root with public and private child modules.
545
    let rootId = try registerModule(
546
        &mut super::MODULE_GRAPH, nil, "root", "mod main; export mod public;"
547
    );
548
    let privateId = try registerModule(&mut super::MODULE_GRAPH, rootId, "public", "{}");
549
    let publicId = try registerModule(
550
        &mut super::MODULE_GRAPH, rootId, "main", "use root::public;"
551
    );
552
553
    // Resolve should succeed: module is public.
554
    let result = try resolveModuleTree(&mut a, rootId);
555
    try expectNoErrors(&result);
556
}
557
558
@test unsafe fn testResolveUseNonPublicType() throws (testing::TestError) {
559
    let mut a = testResolver();
560
561
    // Register root with types module containing a private record.
562
    let rootId = try registerModule(
563
        &mut super::MODULE_GRAPH, nil, "root", "export mod types; mod app;"
564
    );
565
    let typesId = try registerModule(
566
        &mut super::MODULE_GRAPH, rootId, "types", "record Priv { x: i32 }"
567
    );
568
    let appId = try registerModule(
569
        &mut super::MODULE_GRAPH,
570
        rootId,
571
        "app",
572
        "use root::types; fn main() -> types::Priv { return types::Priv { x: 1 }; }"
573
    );
574
575
    // Resolve should fail: record is not public.
576
    let result = try resolveModuleTree(&mut a, rootId);
577
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("Priv"));
578
}
579
580
@test unsafe fn testResolveImportPublicType() throws (testing::TestError) {
581
    let mut a = testResolver();
582
583
    // Register root with types module containing a public record.
584
    let rootId = try registerModule(
585
        &mut super::MODULE_GRAPH, nil, "root", "export mod types; mod app;"
586
    );
587
    let typesId = try registerModule(
588
        &mut super::MODULE_GRAPH, rootId, "types", "export record Pub { x: i32 }"
589
    );
590
    let appId = try registerModule(
591
        &mut super::MODULE_GRAPH,
592
        rootId,
593
        "app",
594
        "use root::types; fn main() -> types::Pub { return types::Pub { x: 1 }; }"
595
    );
596
597
    // Resolve should succeed: record is public.
598
    let result = try resolveModuleTree(&mut a, rootId);
599
    try expectNoErrors(&result);
600
}
601
602
@test unsafe fn testResolveUseNonPublicStatic() throws (testing::TestError) {
603
    let mut a = testResolver();
604
605
    // Register root with statics module containing a private static.
606
    let rootId = try registerModule(
607
        &mut super::MODULE_GRAPH, nil, "root", "export mod statics; mod app;"
608
    );
609
    let staticsId = try registerModule(
610
        &mut super::MODULE_GRAPH, rootId, "statics", "static PRIVATE: i32 = 42;"
611
    );
612
    let appId = try registerModule(
613
        &mut super::MODULE_GRAPH,
614
        rootId,
615
        "app",
616
        "use root::statics; fn main() -> i32 { return statics::PRIVATE; }"
617
    );
618
619
    // Resolve should fail: static is not public.
620
    let result = try resolveModuleTree(&mut a, rootId);
621
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("PRIVATE"));
622
}
623
624
@test unsafe fn testResolveImportPublicStatic() throws (testing::TestError) {
625
    let mut a = testResolver();
626
627
    // Register root with statics module containing a public static.
628
    let rootId = try registerModule(
629
        &mut super::MODULE_GRAPH, nil, "root", "export mod statics; mod app;"
630
    );
631
    let staticsId = try registerModule(
632
        &mut super::MODULE_GRAPH, rootId, "statics", "export static PUBLIC: i32 = 42;"
633
    );
634
    let appId = try registerModule(
635
        &mut super::MODULE_GRAPH,
636
        rootId,
637
        "app",
638
        "use root::statics; fn main() -> i32 { return statics::PUBLIC; }"
639
    );
640
641
    // Resolve should succeed: static is public.
642
    let result = try resolveModuleTree(&mut a, rootId);
643
    try expectNoErrors(&result);
644
}
645
646
@test unsafe fn testResolveAccessSuper() throws (testing::TestError) {
647
    {
648
        let mut a = testResolver();
649
650
        // Test function access.
651
        let rootId = try registerModule(
652
            &mut super::MODULE_GRAPH,
653
            nil,
654
            "root",
655
            "mod child; export fn parentFn() -> i32 { return 42; }"
656
        );
657
        let childId = try registerModule(
658
            &mut super::MODULE_GRAPH,
659
            rootId,
660
            "child",
661
            "fn main() -> i32 { return super::parentFn(); }"
662
        );
663
        let result = try resolveModuleTree(&mut a, rootId);
664
        try expectNoErrors(&result);
665
    }
666
    {
667
        let mut a = testResolver();
668
669
        // Test type access.
670
        let rootId = try registerModule(
671
            &mut super::MODULE_GRAPH,
672
            nil,
673
            "root",
674
            "mod child; export record Point { x: i32, y: i32 }"
675
        );
676
        let childId = try registerModule(
677
            &mut super::MODULE_GRAPH,
678
            rootId,
679
            "child",
680
            "fn make() -> super::Point { return super::Point { x: 1, y: 2 }; }"
681
        );
682
        let result = try resolveModuleTree(&mut a, rootId);
683
        try expectNoErrors(&result);
684
    }
685
}
686
687
/// Test nested super access to union variants (e.g. `super::E::A`).
688
@test unsafe fn testResolveSuperUnionVariant() throws (testing::TestError) {
689
    let mut a = testResolver();
690
691
    let rootId = try registerModule(
692
        &mut super::MODULE_GRAPH, nil, "root", "mod c; export union E { A, B }"
693
    );
694
    let childId = try registerModule(
695
        &mut super::MODULE_GRAPH,
696
        rootId,
697
        "c",
698
        "fn f(x: super::E) { match x { case super::E::A => {}, case super::E::B => {} } }"
699
    );
700
    let result = try resolveModuleTree(&mut a, rootId);
701
    try expectNoErrors(&result);
702
}
703
704
@test unsafe fn testResolveUseSuper() throws (testing::TestError) {
705
    let mut a = testResolver();
706
707
    // Register root with a function, and a child module that uses super to access it.
708
    let rootId = try registerModule(
709
        &mut super::MODULE_GRAPH, nil, "root", "mod joe; export mod kate;"
710
    );
711
    let kateId = try registerModule(&mut super::MODULE_GRAPH, rootId, "kate", "export fn run() {}");
712
    let joeId = try registerModule(
713
        &mut super::MODULE_GRAPH, rootId, "joe", "use super::kate; fn main() { kate::run(); }"
714
    );
715
716
    // Resolve should succeed - super allows accessing parent module.
717
    let result = try resolveModuleTree(&mut a, rootId);
718
    try expectNoErrors(&result);
719
}
720
721
@test unsafe fn testResolveModNotFound() throws (testing::TestError) {
722
    let mut a = testResolver();
723
724
    // Register root that declares a module that doesn't exist.
725
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod unknown;");
726
727
    // Resolve should fail: module doesn't exist.
728
    let result = try resolveModuleTree(&mut a, rootId);
729
    let err = try expectError(&result);
730
    let case resolver::ErrorKind::UnresolvedSymbol(name) = err.kind
731
        else throw testing::TestError::Failed;
732
    try testing::expect(mem::eq(name, "unknown"));
733
}
734
735
@test unsafe fn testResolveDuplicateSubModule() throws (testing::TestError) {
736
    let mut a = testResolver();
737
738
    // Register root that declares a module twice.
739
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod child; mod child;");
740
    let childId = try registerModule(&mut super::MODULE_GRAPH, rootId, "child", "{}");
741
742
    // Resolve should fail: can't declare the same module twice.
743
    let result = try resolveModuleTree(&mut a, rootId);
744
    let err = try expectError(&result);
745
    try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("child"));
746
}
747
748
@test unsafe fn testResolveUseSubModule() throws (testing::TestError) {
749
    let mut a = testResolver();
750
751
    // Register root that declares and imports the same module.
752
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod child; use child;");
753
    let childId = try registerModule(&mut super::MODULE_GRAPH, rootId, "child", "{}");
754
755
    // Resolve should fail: Both `mod` and `use` are trying to create the same binding.
756
    let result = try resolveModuleTree(&mut a, rootId);
757
    let err = try expectError(&result);
758
    try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("child"));
759
}
760
761
@test unsafe fn testResolveDuplicateUse() throws (testing::TestError) {
762
    let mut a = testResolver();
763
764
    // Register a module that imports the same module twice.
765
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod child");
766
    let childId = try registerModule(
767
        &mut super::MODULE_GRAPH, rootId, "child", "use root; use root;"
768
    );
769
770
    // Resolve should fail.
771
    let result = try resolveModuleTree(&mut a, rootId);
772
    let err = try expectError(&result);
773
    try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("root"));
774
}
775
776
/// Test that opaque pointers are allowed in record fields.
777
@test unsafe fn testOpaquePointerInRecordField() throws (testing::TestError) {
778
    let mut a = testResolver();
779
    let result = try resolveProgramStr(&mut a, "record T { x: *opaque }");
780
    try expectNoErrors(&result);
781
}
782
783
/// You cannot use `@sizeOf` or `@alignOf` on opaque type.
784
@test unsafe fn testOpaqueTypeNoSizeOfAlignOf() throws (testing::TestError) {
785
    let mut a = testResolver();
786
787
    let result1 = try resolveExprStr(&mut a, "@sizeOf(opaque)");
788
    let err1 = try expectError(&result1);
789
    try expectErrorKind(&result1, resolver::ErrorKind::OpaqueTypeNotAllowed);
790
791
    let result2 = try resolveExprStr(&mut a, "@alignOf(opaque)");
792
    let err2 = try expectError(&result2);
793
    try expectErrorKind(&result2, resolver::ErrorKind::OpaqueTypeNotAllowed);
794
}
795
796
/// Test that immutable slice/pointer parameters cannot be borrowed mutably.
797
@test unsafe fn testMutableBorrowFromImmutablePointer() throws (testing::TestError) {
798
    let mut a = testResolver();
799
    let program = "fn f(p: *i32) { let x = &mut *p; }";
800
    let result = try resolveProgramStr(&mut a, program);
801
    let err = try expectError(&result);
802
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
803
}
804
805
/// Test that immutable slice parameters cannot be borrowed mutably.
806
@test unsafe fn testMutableBorrowFromImmutableSlice() throws (testing::TestError) {
807
    let mut a = testResolver();
808
    let program = "fn f(s: *[i32]) { let x: *mut i32 = &mut s[0]; }";
809
    let result = try resolveProgramStr(&mut a, program);
810
    let err = try expectError(&result);
811
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
812
}
813
814
/// Test that mutable pointer parameters can be borrowed mutably.
815
@test unsafe fn testMutableBorrowFromMutablePointer() throws (testing::TestError) {
816
    let mut a = testResolver();
817
    let program = "fn f(p: *mut i32) { let x: *mut i32 = &mut *p; }";
818
    let result = try resolveProgramStr(&mut a, program);
819
    try expectNoErrors(&result);
820
}
821
822
/// Test that mutable slice parameters can be borrowed mutably.
823
@test unsafe fn testMutableBorrowFromMutableSlice() throws (testing::TestError) {
824
    let mut a = testResolver();
825
    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";
826
    let result = try resolveProgramStr(&mut a, program);
827
    try expectNoErrors(&result);
828
}
829
830
/// Test borrowing mutably from a field access on a call returning `*mut`.
831
@test unsafe fn testMutableBorrowFromCallReturningMutablePointer() throws (testing::TestError) {
832
    let mut a = testResolver();
833
    let program =
834
        "record Box { x: i32 } fn idBox(b: *mut Box) -> *mut Box { return b; } fn f() { static b: Box = Box { x: 1 }; unsafe { let px: *mut i32 = &mut idBox(&mut b).x; } }";
835
    let result = try resolveProgramStr(&mut a, program);
836
    try expectNoErrors(&result);
837
}
838
839
/// Test that calls returning immutable pointers cannot be mutably borrowed.
840
@test unsafe fn testMutableBorrowFromCallReturningImmutablePointer() throws (testing::TestError) {
841
    let mut a = testResolver();
842
    let program =
843
        "record Box { x: i32 } fn idBox(b: *Box) -> *Box { return b; } fn f() { constant b: Box = Box { x: 1 }; let px: *mut i32 = &mut idBox(&b).x; }";
844
    let result = try resolveProgramStr(&mut a, program);
845
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
846
}
847
848
/// Test borrowing mutably from a public static through scope access.
849
@test unsafe fn testMutableBorrowFromScopeAccessStatic() throws (testing::TestError) {
850
    let mut a = testResolver();
851
852
    let rootId = try registerModule(
853
        &mut super::MODULE_GRAPH, nil, "root", "export mod statics; mod app;"
854
    );
855
    let staticsId = try registerModule(
856
        &mut super::MODULE_GRAPH, rootId, "statics", "export static COUNTER: i32 = 0;"
857
    );
858
    let appId = try registerModule(
859
        &mut super::MODULE_GRAPH,
860
        rootId,
861
        "app",
862
        "use root::statics; fn main() { unsafe { let p: *mut i32 = &mut statics::COUNTER; set *p = 7; } }"
863
    );
864
865
    let result = try resolveModuleTree(&mut a, rootId);
866
    try expectNoErrors(&result);
867
}
868
869
/// Test that constants through scope access cannot be mutably borrowed.
870
@test unsafe fn testMutableBorrowFromScopeAccessConstant() throws (testing::TestError) {
871
    let mut a = testResolver();
872
873
    let rootId = try registerModule(
874
        &mut super::MODULE_GRAPH, nil, "root", "export mod consts; mod app;"
875
    );
876
    let constsId = try registerModule(
877
        &mut super::MODULE_GRAPH, rootId, "consts", "export constant LIMIT: i32 = 7;"
878
    );
879
    let appId = try registerModule(
880
        &mut super::MODULE_GRAPH,
881
        rootId,
882
        "app",
883
        "use root::consts; fn main() { let p: *mut i32 = &mut consts::LIMIT; set *p = 9; }"
884
    );
885
886
    let result = try resolveModuleTree(&mut a, rootId);
887
    try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
888
}
889
890
/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.
891
@test unsafe fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {
892
    let mut a = testResolver();
893
    let program = "fn f() { static x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";
894
    let result = try resolveProgramStr(&mut a, program);
895
    let err = try expectError(&result);
896
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
897
}
898
899
/// Test that mutable pointer to immutable slice cannot be assigned through index.
900
/// This tests the case where we have `*mut *[T]`; the outer pointer is mutable but
901
/// the inner slice is immutable, so we shouldn't be able to mutate the elements.
902
@test unsafe fn testAssignThroughMutablePointerToImmutableSlice() throws (testing::TestError) {
903
    let mut a = testResolver();
904
    let program = "fn f(slice: *[i32]) { let p: *mut *[i32] = &mut slice; set p[0] = 1; }";
905
    let result = try resolveProgramStr(&mut a, program);
906
907
    try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
908
}
909
910
/// Test that mutable slice parameters can be assigned through index.
911
@test unsafe fn testAssignThroughMutableSliceParam() throws (testing::TestError) {
912
    {
913
        // Mutable slice param: direct assignment should work
914
        let mut a = testResolver();
915
        let program = "fn f(slice: *mut [i32]) { set slice[0] = 1; }";
916
        let result = try resolveProgramStr(&mut a, program);
917
        try expectNoErrors(&result);
918
    }
919
    {
920
        // Immutable slice param: direct assignment should fail
921
        let mut a = testResolver();
922
        let program = "fn f(slice: *[i32]) { set slice[0] = 1; }";
923
        let result = try resolveProgramStr(&mut a, program);
924
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
925
    }
926
}
927
928
/// Test range end type coercion with assignable types.
929
@test unsafe fn testRangeEndTypeCoercion() throws (testing::TestError) {
930
    {
931
        let mut a = testResolver();
932
        let program = "fn f(end: u32) { for i in 0..end {} }";
933
        let result = try resolveProgramStr(&mut a, program);
934
        try expectNoErrors(&result);
935
    }
936
    {
937
        let mut a = testResolver();
938
        let program = "fn f(start: u32) { for i in start..9 {} }";
939
        let result = try resolveProgramStr(&mut a, program);
940
        try expectNoErrors(&result);
941
    }
942
}
943
944
/// Mixed-width range bounds require an explicit cast.
945
@test unsafe fn testRangeEndTypeSubType() throws (testing::TestError) {
946
    {
947
        let mut a = testResolver();
948
        let program = "fn f(start: i8, end: u32) { for i in start..end {} }";
949
        let result = try resolveProgramStr(&mut a, program);
950
        let err = try expectError(&result);
951
        try expectTypeMismatch(err, resolver::Type::I8, resolver::Type::U32);
952
    }
953
    {
954
        let mut a = testResolver();
955
        let program = "fn f(start: i8, end: u32) { for i in (start as u32)..end {} }";
956
        let result = try resolveProgramStr(&mut a, program);
957
        try expectNoErrors(&result);
958
    }
959
}
960
961
/// Test that try-catch expressions in statement context accept mismatched types.
962
@test unsafe fn testTryCatchInStatementContextTypeMismatchOk() throws (testing::TestError) {
963
    let mut a = testResolver();
964
    let program = "fn f() { try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
965
    let result = try resolveProgramStr(&mut a, program);
966
    try expectNoErrors(&result);
967
}
968
969
/// Test that try-catch blocks in value context require divergence or void.
970
@test unsafe fn testTryCatchInValueContextTypeMismatch() throws (testing::TestError) {
971
    let mut a = testResolver();
972
    let program =
973
        "fn f() -> bool { return try g() catch {}; } fn g() -> bool throws (i32) { panic; }";
974
    let result = try resolveProgramStr(&mut a, program);
975
    let err = try expectError(&result);
976
    try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Void);
977
}
978
979
/// Test that a catch block whose value an unannotated binding uses must
980
/// diverge, with or without an error binding or a type.
981
@test unsafe fn testTryCatchInferredBindingRequiresValue() throws (testing::TestError) {
982
    let programs: [*[u8]; 3] = [
983
        "fn f(n: bool) -> bool { let v = try g() catch { n; }; return v; } fn g() -> bool throws (i32) { panic; }",
984
        "fn f(n: bool) -> bool { let v = try g() catch e { n; }; return v; } fn g() -> bool throws (i32) { panic; }",
985
        "fn f(n: bool) -> bool { let v = try g() catch e as i32 { n; }; return v; } fn g() -> bool throws (i32) { panic; }",
986
    ];
987
    for program in programs {
988
        let mut a = testResolver();
989
        let result = try resolveProgramStr(&mut a, program);
990
        let err = try expectError(&result);
991
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Void);
992
    }
993
    let mut a = testResolver();
994
    let program =
995
        "fn f() -> bool { let v = try g() catch { return false; }; return v; } fn g() -> bool throws (i32) { panic; }";
996
    let result = try resolveProgramStr(&mut a, program);
997
    try expectNoErrors(&result);
998
}
999
1000
/// Test that try-catch blocks in value context work when they diverge.
1001
@test unsafe fn testTryCatchInValueContextDiverges() throws (testing::TestError) {
1002
    let mut a = testResolver();
1003
    let program =
1004
        "fn f() -> bool { return try g() catch { return false; }; } fn g() -> bool throws (i32) { panic; }";
1005
    let result = try resolveProgramStr(&mut a, program);
1006
    try expectNoErrors(&result);
1007
}
1008
1009
/// Test that `try?` lifts result type to optional.
1010
@test unsafe fn testTryOptionalLiftsToOptional() throws (testing::TestError) {
1011
    let mut a = testResolver();
1012
    let program =
1013
        "record S {} fn f() -> ?*S { return try? g(); } fn g() -> *S throws (i32) { panic; }";
1014
    let result = try resolveProgramStr(&mut a, program);
1015
    try expectNoErrors(&result);
1016
}
1017
1018
/// Test that record fields can be assigned if the record binding is mutable.
1019
@test unsafe fn testMutableAssignToMutableRecordBinding() throws (testing::TestError) {
1020
    let mut a = testResolver();
1021
    let program = "record S { x: i32 } fn f() { let mut s = S { x: 1 }; set s.x = 2; }";
1022
    let result = try resolveProgramStr(&mut a, program);
1023
    try expectNoErrors(&result);
1024
}
1025
1026
/// Test that record fields cannot be assigned if the record binding is immutable.
1027
@test unsafe fn testMutableAssignToImmutableRecordBinding() throws (testing::TestError) {
1028
    let mut a = testResolver();
1029
    let program = "record S { x: i32 } fn f() { let s = S { x: 1 }; set s.x = 2; }";
1030
    let result = try resolveProgramStr(&mut a, program);
1031
    let err = try expectError(&result);
1032
    try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1033
}
1034
1035
/// Test that record fields can be assigned through a mutable pointer.
1036
@test unsafe fn testMutableAssignToMutablePointerToRecord() throws (testing::TestError) {
1037
    let mut a = testResolver();
1038
    let program = "record S { x: i32 } fn f(p: *mut S) { set p.x = 2; }";
1039
    let result = try resolveProgramStr(&mut a, program);
1040
    try expectNoErrors(&result);
1041
}
1042
1043
/// Test that record fields cannot be assigned through an immutable pointer.
1044
@test unsafe fn testMutableAssignToImmutablePointerToRecord() throws (testing::TestError) {
1045
    let mut a = testResolver();
1046
    let program = "record S { x: i32 } fn f(p: *S) { set p.x = 2; }";
1047
    let result = try resolveProgramStr(&mut a, program);
1048
    let err = try expectError(&result);
1049
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
1050
}
1051
1052
// Opaque pointer tests.
1053
1054
/// You can assign any pointer (*T) to an opaque pointer (*opaque) without a cast.
1055
@test unsafe fn testOpaquePointerAutoCoercion() throws (testing::TestError) {
1056
    let mut a = testResolver();
1057
    let result = try resolveProgramStr(
1058
        &mut a,
1059
        "unsafe fn f(x: *i32) { let mut ptr: *i32 = x; let o: *opaque = ptr; set ptr = o as *i32; }"
1060
    );
1061
    try expectNoErrors(&result);
1062
}
1063
1064
/// You cannot assign an opaque pointer to a non-opaque pointer without a cast.
1065
@test unsafe fn testOpaquePointerNoReverseCoercion() throws (testing::TestError) {
1066
    let mut a = testResolver();
1067
    let result = try resolveProgramStr(
1068
        &mut a, "fn f(a: *i32) { let o: *opaque = a; let ptr: *i32 = o; }"
1069
    );
1070
    let err = try expectError(&result);
1071
    let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
1072
        else throw testing::TestError::Failed;
1073
    let case resolver::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
1074
        else throw testing::TestError::Failed;
1075
    let case resolver::Type::Pointer { target: actualTarget, .. } = mismatch.actual
1076
        else throw testing::TestError::Failed;
1077
1078
    try testing::expect(*expectedTarget == resolver::Type::I32);
1079
    try testing::expect(*actualTarget == resolver::Type::Opaque);
1080
}
1081
1082
/// You cannot have a value of type `opaque` (function parameter).
1083
@test unsafe fn testOpaqueValue() throws (testing::TestError) {
1084
    {
1085
        let mut a = testResolver();
1086
        let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
1087
        let err = try expectError(&result);
1088
        try expectErrorKind(&result, resolver::ErrorKind::OpaqueTypeNotAllowed);
1089
    }
1090
    {
1091
        let mut a = testResolver();
1092
        let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
1093
        let err = try expectError(&result);
1094
        try expectErrorKind(&result, resolver::ErrorKind::OpaqueTypeNotAllowed);
1095
    }
1096
    {
1097
        let mut a = testResolver();
1098
        let result = try resolveProgramStr(&mut a, "record R { x: opaque }");
1099
        let err = try expectError(&result);
1100
        try expectErrorKind(&result, resolver::ErrorKind::OpaqueTypeNotAllowed);
1101
    }
1102
}
1103
1104
/// You cannot dereference an opaque pointer, you have to cast it first.
1105
@test unsafe fn testOpaquePointerNoDereference() throws (testing::TestError) {
1106
    let mut a = testResolver();
1107
    let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = *o; }");
1108
    let err = try expectError(&result);
1109
    try expectErrorKind(&result, resolver::ErrorKind::OpaqueTypeDeref);
1110
}
1111
1112
/// Test that you can dereference after casting.
1113
@test unsafe fn testOpaquePointerDereferenceAfterCast() throws (testing::TestError) {
1114
    let mut a = testResolver();
1115
    let result = try resolveProgramStr(
1116
        &mut a, "unsafe fn f() { let o: *opaque = undefined; let x = *(o as *i32); }"
1117
    );
1118
    try expectNoErrors(&result);
1119
}
1120
1121
/// You cannot do pointer arithmetic with an opaque pointer.
1122
@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
1123
    {
1124
        let mut a = testResolver();
1125
        let result = try resolveProgramStr(
1126
            &mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o + 1; }"
1127
        );
1128
        let err = try expectError(&result);
1129
        try expectErrorKind(&result, resolver::ErrorKind::OpaquePointerArithmetic);
1130
    }
1131
    {
1132
        let mut a = testResolver();
1133
        let result = try resolveProgramStr(
1134
            &mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 + o; }"
1135
        );
1136
        let err = try expectError(&result);
1137
        try expectErrorKind(&result, resolver::ErrorKind::OpaquePointerArithmetic);
1138
    }
1139
    {
1140
        let mut a = testResolver();
1141
        let result = try resolveProgramStr(
1142
            &mut a, "fn f(a: *i32) { let o: *opaque = a; let x = o - 1; }"
1143
        );
1144
        let err = try expectError(&result);
1145
        try expectErrorKind(&result, resolver::ErrorKind::OpaquePointerArithmetic);
1146
    }
1147
    {
1148
        let mut a = testResolver();
1149
        let result = try resolveProgramStr(
1150
            &mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }"
1151
        );
1152
        let err = try expectError(&result);
1153
        try expectErrorKind(&result, resolver::ErrorKind::OpaquePointerArithmetic);
1154
    }
1155
}
1156
1157
// Wildcard import/reexport tests.
1158
1159
/// Test transitive re-export.
1160
@test unsafe fn testWildcardReexportTransitive() throws (testing::TestError) {
1161
    let mut a = testResolver();
1162
1163
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "mod a; export mod b;");
1164
    let aId = try registerModule(
1165
        &mut super::MODULE_GRAPH,
1166
        rootId,
1167
        "a",
1168
        "use root::b; fn main() -> i32 { return b::helper() + b::MAX; }"
1169
    );
1170
    let bId = try registerModule(&mut super::MODULE_GRAPH, rootId, "b", "mod c; export use c::*;");
1171
    let cId = try registerModule(
1172
        &mut super::MODULE_GRAPH,
1173
        bId,
1174
        "c",
1175
        "mod d; export use d::*; export fn helper() -> i32 { return 42; }"
1176
    );
1177
    let dId = try registerModule(
1178
        &mut super::MODULE_GRAPH, cId, "d", "export constant MAX: i32 = 100;"
1179
    );
1180
1181
    let result = try resolveModuleTree(&mut a, rootId);
1182
    try expectNoErrors(&result);
1183
}
1184
1185
/// Test that wildcard import can access public symbols.
1186
@test unsafe fn testWildcardImportPublicOnly() throws (testing::TestError) {
1187
    let mut a = testResolver();
1188
1189
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "export mod b; mod a;");
1190
    let bId = try registerModule(
1191
        &mut super::MODULE_GRAPH,
1192
        rootId,
1193
        "b",
1194
        "export record Value { number: i32 } export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }"
1195
    );
1196
    let aId = try registerModule(
1197
        &mut super::MODULE_GRAPH,
1198
        rootId,
1199
        "a",
1200
        "use root::b::*; fn id(value: Value) -> Value { return value; } fn main() -> i32 { return public() + id(Value { number: 2 }).number; }"
1201
    );
1202
1203
    let result = try resolveModuleTree(&mut a, rootId);
1204
    try expectNoErrors(&result);
1205
}
1206
1207
/// Test that wildcard import cannot access private symbols.
1208
@test unsafe fn testWildcardImportSkipsPrivate() throws (testing::TestError) {
1209
    let mut a = testResolver();
1210
1211
    let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "export mod b; mod a;");
1212
    let bId = try registerModule(
1213
        &mut super::MODULE_GRAPH,
1214
        rootId,
1215
        "b",
1216
        "export fn public() -> i32 { return 1; } fn private() -> i32 { return 2; }"
1217
    );
1218
    let aId = try registerModule(
1219
        &mut super::MODULE_GRAPH,
1220
        rootId,
1221
        "a",
1222
        "use root::b::*; fn main() -> i32 { return private(); }"
1223
    );
1224
1225
    let result = try resolveModuleTree(&mut a, rootId);
1226
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("private"));
1227
}
1228
1229
/// Test that a constant array can use another constant as its length.
1230
@test unsafe fn testConstArrayWithConstLength() throws (testing::TestError) {
1231
    let mut a = testResolver();
1232
    let program = "constant LEN: u32 = 3; constant ARR: [i32; LEN] = [1, 2, 3];";
1233
    let result = try resolveProgramStr(&mut a, program);
1234
    try expectNoErrors(&result);
1235
1236
    // Verify the array constant has the correct type with length 3.
1237
    let arrStmt = try getBlockStmt(result.root, 1);
1238
    let sym = resolver::symbolFor(&a, arrStmt) else throw testing::TestError::Failed;
1239
    let case resolver::SymbolData::Constant { type: resolver::Type::Array(arrType), .. } =
1240
        a.symbols[*sym].data else throw testing::TestError::Failed;
1241
    try testing::expect(arrType.length == 3);
1242
}
1243
1244
/// An array type can have a length of up to 2^31 - 1 elements.
1245
@test unsafe fn testArrayLengthAtLimit() throws (testing::TestError) {
1246
    let mut a = testResolver();
1247
    let result = try resolveProgramStr(&mut a, "fn f(p: *[u8; 2147483647]) {}");
1248
    try expectNoErrors(&result);
1249
}
1250
1251
/// An array type of 2^31 elements is rejected.
1252
@test unsafe fn testArrayLengthAboveLimit() throws (testing::TestError) {
1253
    let mut a = testResolver();
1254
    let result = try resolveProgramStr(&mut a, "fn f(p: *[u8; 2147483648]) {}");
1255
    try expectErrorKind(&result, resolver::ErrorKind::ArrayTooLong);
1256
}
1257
1258
/// A repeated array literal of 2^31 elements is rejected.
1259
@test unsafe fn testArrayRepeatAboveLimit() throws (testing::TestError) {
1260
    let mut a = testResolver();
1261
    let result = try resolveProgramStr(&mut a, "fn f() { let a = [0; 2147483648]; }");
1262
    try expectErrorKind(&result, resolver::ErrorKind::ArrayTooLong);
1263
}
1264
1265
/// Test that a record field can use a constant as its array length.
1266
@test unsafe fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
1267
    let mut a = testResolver();
1268
    let program = "constant SIZE: u32 = 4; record Buffer { data: [i32; SIZE], }";
1269
    let result = try resolveProgramStr(&mut a, program);
1270
    try expectNoErrors(&result);
1271
}
1272
1273
/// Test that a constant can have a record literal value (lazy record body resolution).
1274
@test unsafe fn testConstWithRecordLiteral() throws (testing::TestError) {
1275
    let mut a = testResolver();
1276
    let program = "record Point { x: i32, y: i32 } constant ORIGIN: Point = Point { x: 0, y: 0 };";
1277
    let result = try resolveProgramStr(&mut a, program);
1278
    try expectNoErrors(&result);
1279
}
1280
1281
/// Test that a constant can have a union variant value (lazy union body resolution).
1282
@test unsafe fn testConstWithUnionVariant() throws (testing::TestError) {
1283
    let mut a = testResolver();
1284
    let program = "union Color { Red, Green, Blue } constant DEFAULT: Color = Color::Red;";
1285
    let result = try resolveProgramStr(&mut a, program);
1286
    try expectNoErrors(&result);
1287
}
1288
1289
/// Test that record field types can reference imported types.
1290
///
1291
/// This tests that `use` statements are processed before record body resolution,
1292
/// allowing record fields to use types from imported modules.
1293
@test unsafe fn testRecordFieldUsesImportedType() throws (testing::TestError) {
1294
    let mut a = testResolver();
1295
1296
    let rootId = try registerModule(
1297
        &mut super::MODULE_GRAPH, nil, "root", "export mod types; mod scanner;"
1298
    );
1299
    let typesId = try registerModule(
1300
        &mut super::MODULE_GRAPH, rootId, "types", "export record Pool { count: u32 }"
1301
    );
1302
    let scannerId = try registerModule(
1303
        &mut super::MODULE_GRAPH,
1304
        rootId,
1305
        "scanner",
1306
        "use root::types; record Scanner { pool: *types::Pool }"
1307
    );
1308
1309
    let result = try resolveModuleTree(&mut a, rootId);
1310
    try expectNoErrors(&result);
1311
}
1312
1313
/// Test that imported constants can be used in array size expressions.
1314
///
1315
/// This tests that constant values are propagated through scope access expressions,
1316
/// enabling compile-time evaluation of array sizes using imported constants.
1317
@test unsafe fn testImportedConstantInArraySize() throws (testing::TestError) {
1318
    let mut a = testResolver();
1319
1320
    let rootId = try registerModule(
1321
        &mut super::MODULE_GRAPH, nil, "root", "export mod consts; mod app;"
1322
    );
1323
    let constsId = try registerModule(
1324
        &mut super::MODULE_GRAPH, rootId, "consts", "export constant SIZE: u32 = 8;"
1325
    );
1326
    let appId = try registerModule(
1327
        &mut super::MODULE_GRAPH,
1328
        rootId,
1329
        "app",
1330
        "use root::consts; static BUFFER: [u8; consts::SIZE] = [0; consts::SIZE];"
1331
    );
1332
1333
    let result = try resolveModuleTree(&mut a, rootId);
1334
    try expectNoErrors(&result);
1335
}
1336
1337
/// Test that `if let case` binds payload variables in the then branch.
1338
///
1339
/// When using `if let case Union::Variant(x) = expr { ... }`, the variable `x` should
1340
/// be bound to the payload value within the then branch scope.
1341
@test unsafe fn testResolveIfCaseBindsPayload() throws (testing::TestError) {
1342
    let mut a = testResolver();
1343
    let program =
1344
        "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value { return x; } return 0; }";
1345
    let result = try resolveProgramStr(&mut a, program);
1346
    try expectNoErrors(&result);
1347
}
1348
1349
/// Test that `if let case` payload binding is scoped to the then branch.
1350
///
1351
/// The payload variable should not be accessible outside the then branch.
1352
@test unsafe fn testResolveIfCasePayloadScopeError() throws (testing::TestError) {
1353
    let mut a = testResolver();
1354
    let program =
1355
        "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { if let case Opt::Some(x) = value {} return x; }";
1356
    let result = try resolveProgramStr(&mut a, program);
1357
    let err = try expectError(&result);
1358
    let case resolver::ErrorKind::UnresolvedSymbol(name) = err.kind
1359
        else throw testing::TestError::Failed;
1360
    try testing::expect(mem::eq(name, "x"));
1361
}
1362
1363
/// Test that `let case` binds payload variables in the current scope.
1364
///
1365
/// When using `let case Union::Variant(x) = expr else { ... }`, the variable `x`
1366
/// should be bound in the scope after the statement.
1367
@test unsafe fn testResolveLetCaseElseBindsPayload() throws (testing::TestError) {
1368
    let mut a = testResolver();
1369
    let program =
1370
        "union Opt { Some(i32), None } fn f(value: Opt) -> i32 { let case Opt::Some(x) = value else panic; return x; }";
1371
    let result = try resolveProgramStr(&mut a, program);
1372
    try expectNoErrors(&result);
1373
}
1374
1375
// Pattern union checks ////////////////////////////////////////////////////////
1376
1377
/// Require the first error to be a mismatch between a record subject and a union pattern.
1378
///
1379
/// `expected` is the subject type (or an optional of it) and `actual` is the pattern type.
1380
unsafe fn expectRecordUnionMismatch(program: *[u8], optional: bool) throws (testing::TestError) {
1381
    let mut a = testResolver();
1382
    let result = try resolveProgramStr(&mut a, program);
1383
    let err = try expectError(&result);
1384
    let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
1385
        else throw testing::TestError::Failed;
1386
1387
    let mut expectedTy = mismatch.expected;
1388
    if optional {
1389
        let case resolver::Type::Optional(inner) = mismatch.expected
1390
            else throw testing::TestError::Failed;
1391
        set expectedTy = *inner;
1392
    }
1393
    let case resolver::Type::Nominal(recordId) = expectedTy else throw testing::TestError::Failed;
1394
    let case resolver::NominalType::Record(_) = a.nominals[*recordId]
1395
        else throw testing::TestError::Failed;
1396
1397
    let case resolver::Type::Nominal(unionId) = mismatch.actual
1398
        else throw testing::TestError::Failed;
1399
    let case resolver::NominalType::Union(_) = a.nominals[*unionId]
1400
        else throw testing::TestError::Failed;
1401
}
1402
1403
/// Require a mismatch between a record subject and a union pattern, without an optional.
1404
unsafe fn expectIdOtherMismatch(program: *[u8]) throws (testing::TestError) {
1405
    try expectRecordUnionMismatch(program, false);
1406
}
1407
1408
/// A `let case` variant pattern of another union must not match a record subject.
1409
@test unsafe fn testResolveLetCaseVariantOfOtherUnionMismatch() throws (testing::TestError) {
1410
    try expectIdOtherMismatch(
1411
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: Id) -> i32 { let case Other::Some(_) = id else return 1; return 0; }"
1412
    );
1413
}
1414
1415
/// An `if let case` variant pattern of another union must not match a record subject.
1416
@test unsafe fn testResolveIfLetCaseVariantOfOtherUnionMismatch() throws (testing::TestError) {
1417
    try expectIdOtherMismatch(
1418
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: Id) -> i32 { if let case Other::Some(_) = id { return 0; } return 1; }"
1419
    );
1420
}
1421
1422
/// A `while let case` variant pattern of another union must not match a record subject.
1423
@test unsafe fn testResolveWhileLetCaseVariantOfOtherUnionMismatch() throws (testing::TestError) {
1424
    try expectIdOtherMismatch(
1425
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: Id) { while let case Other::Some(_) = id { break; } }"
1426
    );
1427
}
1428
1429
/// A `match` arm variant pattern of another union must not match a record subject.
1430
@test unsafe fn testResolveMatchVariantOfOtherUnionMismatch() throws (testing::TestError) {
1431
    try expectIdOtherMismatch(
1432
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: Id) -> i32 { match id { case Other::Some(_) => return 0, else => return 1 } }"
1433
    );
1434
}
1435
1436
/// A variant pattern of another union inside a record field must not match the field type.
1437
@test unsafe fn testResolveNestedRecordFieldVariantOfOtherUnionMismatch()
1438
    throws (testing::TestError)
1439
{
1440
    try expectIdOtherMismatch(
1441
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } record Wrap(Id); fn f(w: Wrap) -> i32 { let case Wrap(Other::Some(_)) = w else return 1; return 0; }"
1442
    );
1443
}
1444
1445
/// A variant pattern of another union inside a variant payload must not match the payload field
1446
/// type.
1447
@test unsafe fn testResolveNestedPayloadVariantOfOtherUnionMismatch() throws (testing::TestError) {
1448
    try expectIdOtherMismatch(
1449
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } union Outer { Wrap(Id), Done } fn f(o: Outer) -> i32 { let case Outer::Wrap(Other::Some(_)) = o else return 1; return 0; }"
1450
    );
1451
}
1452
1453
/// A variant pattern of another union must not match through a reference to a record.
1454
@test unsafe fn testResolveRefVariantOfOtherUnionMismatch() throws (testing::TestError) {
1455
    try expectIdOtherMismatch(
1456
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: &Id) -> i32 { let case Other::Some(_) = id else return 1; return 0; }"
1457
    );
1458
}
1459
1460
/// A brace variant pattern of another union must not match a labeled record subject.
1461
@test unsafe fn testResolveLetCaseRecordLitVariantOfOtherUnionMismatch()
1462
    throws (testing::TestError)
1463
{
1464
    try expectRecordUnionMismatch(
1465
        "record Id { value: u32 } union Other: Copy { Some { value: u32 }, Nothing } fn f(id: Id) -> i32 { let case Other::Some { value } = id else return 1; return 0; }",
1466
        false
1467
    );
1468
}
1469
1470
/// A record pattern of another record type must not match a record subject.
1471
@test unsafe fn testResolveLetCaseRecordOfOtherRecordMismatch() throws (testing::TestError) {
1472
    let mut a = testResolver();
1473
    let program =
1474
        "record Id(u32): Copy; record Pair(u32): Copy; fn f(id: Id) -> i32 { let case Pair(_) = id else return 1; return 0; }";
1475
    let result = try resolveProgramStr(&mut a, program);
1476
    let err = try expectError(&result);
1477
    let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
1478
        else throw testing::TestError::Failed;
1479
    let case resolver::Type::Nominal(expectedId) = mismatch.expected
1480
        else throw testing::TestError::Failed;
1481
    let case resolver::Type::Nominal(actualId) = mismatch.actual
1482
        else throw testing::TestError::Failed;
1483
    let case resolver::NominalType::Record(_) = a.nominals[*expectedId]
1484
        else throw testing::TestError::Failed;
1485
    let case resolver::NominalType::Record(_) = a.nominals[*actualId]
1486
        else throw testing::TestError::Failed;
1487
    try testing::expect(*expectedId <> *actualId);
1488
}
1489
1490
/// A variant pattern of another union must not match an optional record subject.
1491
@test unsafe fn testResolveOptionalRecordVariantOfOtherUnionMismatch() throws (testing::TestError) {
1492
    try expectRecordUnionMismatch(
1493
        "record Id(u32): Copy; union Other: Copy { Some(u32), Nothing } fn f(id: ?Id) -> i32 { match id { case Other::Some(_) => return 0, case nil => return 1 } }",
1494
        true
1495
    );
1496
}
1497
1498
/// A variant pattern of the subject union matches through a reference.
1499
@test unsafe fn testResolveRefVariantOfSubjectUnionOk() throws (testing::TestError) {
1500
    let mut a = testResolver();
1501
    let program =
1502
        "union Other: Copy { Some(u32), Nothing } fn f(o: &Other) -> i32 { let case Other::Some(_) = o else return 1; return 0; }";
1503
    let result = try resolveProgramStr(&mut a, program);
1504
    try expectNoErrors(&result);
1505
}
1506
1507
/// A nested variant pattern of the field union is accepted inside a record pattern.
1508
@test unsafe fn testResolveNestedRecordFieldVariantOfSubjectUnionOk() throws (testing::TestError) {
1509
    let mut a = testResolver();
1510
    let program =
1511
        "union Other: Copy { Some(u32), Nothing } record Wrap(Other); fn f(w: Wrap) -> i32 { let case Wrap(Other::Some(x)) = w else return 1; return 0; }";
1512
    let result = try resolveProgramStr(&mut a, program);
1513
    try expectNoErrors(&result);
1514
}
1515
1516
/// A nested variant pattern of the payload union is accepted inside a variant payload.
1517
@test unsafe fn testResolveNestedPayloadVariantOfSubjectUnionOk() throws (testing::TestError) {
1518
    let mut a = testResolver();
1519
    let program =
1520
        "union Other: Copy { Some(u32), Nothing } union Outer { Wrap(Other), Done } fn f(o: Outer) -> i32 { let case Outer::Wrap(Other::Some(x)) = o else return 1; return 0; }";
1521
    let result = try resolveProgramStr(&mut a, program);
1522
    try expectNoErrors(&result);
1523
}
1524
1525
// Optional union variant patterns /////////////////////////////////////////////
1526
1527
/// Require the first error to be a mismatch between two different unions.
1528
///
1529
/// A variant pattern of another union is checked against the union inside the optional subject.
1530
unsafe fn expectUnionUnionMismatch(program: *[u8]) throws (testing::TestError) {
1531
    let mut a = testResolver();
1532
    let result = try resolveProgramStr(&mut a, program);
1533
    let err = try expectError(&result);
1534
    let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
1535
        else throw testing::TestError::Failed;
1536
    let case resolver::Type::Nominal(expectedId) = mismatch.expected
1537
        else throw testing::TestError::Failed;
1538
    let case resolver::Type::Nominal(actualId) = mismatch.actual
1539
        else throw testing::TestError::Failed;
1540
    let case resolver::NominalType::Union(_) = a.nominals[*expectedId]
1541
        else throw testing::TestError::Failed;
1542
    let case resolver::NominalType::Union(_) = a.nominals[*actualId]
1543
        else throw testing::TestError::Failed;
1544
    try testing::expect(*expectedId <> *actualId);
1545
}
1546
1547
/// Require that a program resolves without errors.
1548
unsafe fn expectProgramOk(program: *[u8]) throws (testing::TestError) {
1549
    let mut a = testResolver();
1550
    let result = try resolveProgramStr(&mut a, program);
1551
    try expectNoErrors(&result);
1552
}
1553
1554
/// A variant pattern of the optional's union is accepted in a `match` arm.
1555
@test unsafe fn testResolveOptionalVariantOfSubjectUnionOk() throws (testing::TestError) {
1556
    try expectProgramOk(
1557
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, else => return 1 } }"
1558
    );
1559
}
1560
1561
/// A void variant pattern of the optional's union is accepted in a `match` arm.
1562
@test unsafe fn testResolveOptionalVoidVariantOfSubjectUnionOk() throws (testing::TestError) {
1563
    try expectProgramOk(
1564
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Nothing => return 0, else => return 1 } }"
1565
    );
1566
}
1567
1568
/// A variant pattern of a union without payloads is accepted on an optional subject.
1569
@test unsafe fn testResolveOptionalAllVoidUnionVariantOk() throws (testing::TestError) {
1570
    try expectProgramOk(
1571
        "union Color: Copy { Red, Green } fn f(c: ?Color) -> i32 { match c { case Color::Red => return 0, case nil => return 1, else => return 2 } }"
1572
    );
1573
}
1574
1575
/// A record-style variant pattern is accepted on an optional subject.
1576
@test unsafe fn testResolveOptionalRecordStyleVariantOk() throws (testing::TestError) {
1577
    try expectProgramOk(
1578
        "union Cmd: Copy { Move { dx: i32, dy: i32 }, Stop } fn f(c: ?Cmd) -> i32 { match c { case Cmd::Move { dx, dy } => return dx + dy, else => return 0 } }"
1579
    );
1580
}
1581
1582
/// A variant pattern binds the payload with the payload type, as for a plain union subject.
1583
@test unsafe fn testResolveOptionalVariantBindsPayloadType() throws (testing::TestError) {
1584
    try expectProgramOk(
1585
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> u32 { match o { case Other::Some(x) => { let y: u32 = x; return y; } else => return 0 } }"
1586
    );
1587
    try expectProgramError(
1588
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(x) => { let y: bool = x; return 0; } else => return 1 } }",
1589
        resolver::ErrorKind::TypeMismatch(resolver::TypeMismatch {
1590
            expected: resolver::Type::Bool, actual: resolver::Type::U32
1591
        })
1592
    );
1593
}
1594
1595
/// A variant pattern of a reference to an optional union binds a reference to the payload.
1596
@test unsafe fn testResolveOptionalVariantThroughRefOk() throws (testing::TestError) {
1597
    try expectProgramOk(
1598
        "union Other: Copy { Some(u32), Nothing } fn f(o: &?Other) -> u32 { match o { case Other::Some(x) => return *x, else => return 0 } }"
1599
    );
1600
}
1601
1602
/// A nested variant pattern is accepted inside the payload of a variant on an optional subject.
1603
@test unsafe fn testResolveOptionalNestedVariantOk() throws (testing::TestError) {
1604
    try expectProgramOk(
1605
        "union Inner: Copy { A(u32), B } union Outer: Copy { Wrap(Inner), Done } fn f(o: ?Outer) -> u32 { match o { case Outer::Wrap(Inner::A(x)) => return x, else => return 0 } }"
1606
    );
1607
}
1608
1609
/// A variant pattern is accepted on an optional record field.
1610
@test unsafe fn testResolveOptionalFieldVariantOk() throws (testing::TestError) {
1611
    try expectProgramOk(
1612
        "union Other: Copy { Some(u32), Nothing } record Slot: Copy { id: u32, other: ?Other } fn f(s: Slot) -> u32 { match s { case Slot { other: Other::Some(x), .. } => return x, else => return 0 } }"
1613
    );
1614
}
1615
1616
/// A variant pattern is accepted in `if let case`, `let case`, and `while let case` on an optional
1617
/// subject.
1618
@test unsafe fn testResolveOptionalVariantInConditionsOk() throws (testing::TestError) {
1619
    try expectProgramOk(
1620
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> u32 { if let case Other::Some(x) = o { return x; } return 0; }"
1621
    );
1622
    try expectProgramOk(
1623
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> u32 { let case Other::Some(x) = o else return 0; return x; }"
1624
    );
1625
    try expectProgramOk(
1626
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) { while let case Other::Some(_) = o { break; } }"
1627
    );
1628
}
1629
1630
/// The `nil` pattern still matches the absent case beside variant patterns.
1631
@test unsafe fn testResolveOptionalNilBesideVariantOk() throws (testing::TestError) {
1632
    try expectProgramOk(
1633
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case nil => return 2, else => return 3 } }"
1634
    );
1635
    try expectProgramOk(
1636
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, case nil => return 2 } }"
1637
    );
1638
}
1639
1640
/// An `else` or `_` arm is unreachable when `nil` and every variant are named, as for a
1641
/// plain union with every variant.
1642
@test unsafe fn testResolveOptionalUnionElseUnreachable() throws (testing::TestError) {
1643
    try expectProgramError(
1644
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, case nil => return 2, else => return 3 } }",
1645
        resolver::ErrorKind::UnreachableElse
1646
    );
1647
    try expectProgramError(
1648
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case nil => return 2, case Other::Nothing => return 1, case Other::Some(_) => return 0, _ => return 3 } }",
1649
        resolver::ErrorKind::UnreachableElse
1650
    );
1651
    try expectProgramError(
1652
        "union Color: Copy { Red, Green } fn f(c: &?Color) -> i32 { match c { case Color::Red => return 1, case Color::Green => return 2, case nil => return 0, else => return 3 } }",
1653
        resolver::ErrorKind::UnreachableElse
1654
    );
1655
    try expectProgramError(
1656
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, case nil => return 2, case _ => return 3 } }",
1657
        resolver::ErrorKind::UnreachableElse
1658
    );
1659
    try expectProgramError(
1660
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case nil => return 2, v => return 3, case Other::Some(_) => return 0, case Other::Nothing => return 1 } }",
1661
        resolver::ErrorKind::UnreachableElse
1662
    );
1663
}
1664
1665
/// An `else` arm still covers a case when a variant is missing, guarded, or `nil` is missing.
1666
@test unsafe fn testResolveOptionalUnionElseStillCoversOk() throws (testing::TestError) {
1667
    try expectProgramOk(
1668
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case nil => return 2, else => return 3 } }"
1669
    );
1670
    try expectProgramOk(
1671
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(x) if x > 0 => return 0, case Other::Nothing => return 1, case nil => return 2, else => return 3 } }"
1672
    );
1673
    try expectProgramOk(
1674
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, else => return 3 } }"
1675
    );
1676
    try expectProgramOk(
1677
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case nil => return 2, v => return 3 } }"
1678
    );
1679
}
1680
1681
/// A variant named by two unguarded arms is a duplicate, as for a plain union. A variant
1682
/// whose arms have refining sub-patterns may appear in several arms.
1683
@test unsafe fn testResolveOptionalUnionDuplicateVariantError() throws (testing::TestError) {
1684
    try expectProgramError(
1685
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Some(_) => return 1, case Other::Nothing => return 2, case nil => return 3 } }",
1686
        resolver::ErrorKind::DuplicateMatchPattern
1687
    );
1688
    try expectProgramError(
1689
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_), Other::Some(_) => return 0, case Other::Nothing => return 2, case nil => return 3 } }",
1690
        resolver::ErrorKind::DuplicateMatchPattern
1691
    );
1692
    try expectProgramError(
1693
        "union Color: Copy { Red, Green } fn f(c: &?Color) -> i32 { match c { case Color::Red => return 1, case Color::Red => return 2, case Color::Green => return 3, case nil => return 0 } }",
1694
        resolver::ErrorKind::DuplicateMatchPattern
1695
    );
1696
    try expectProgramError(
1697
        "union Other: Copy { Some(u32), Nothing } fn f(o: Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Some(_) => return 1, case Other::Nothing => return 2 } }",
1698
        resolver::ErrorKind::DuplicateMatchPattern
1699
    );
1700
    try expectProgramError(
1701
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case nil => return 0, case nil => return 1, case Other::Some(_) => return 2, case Other::Nothing => return 3 } }",
1702
        resolver::ErrorKind::DuplicateMatchPattern
1703
    );
1704
    try expectProgramOk(
1705
        "union Inner: Copy { A(u32), B } union Outer: Copy { Wrap(Inner), Done } fn f(o: ?Outer) -> i32 { match o { case Outer::Wrap(Inner::A(x)) => return x as i32, case Outer::Wrap(Inner::B) => return 1, case Outer::Wrap(_) => return 4, case Outer::Done => return 2, case nil => return 3 } }"
1706
    );
1707
}
1708
1709
/// A variant pattern whose payload is missing or unexpected is rejected on an optional subject.
1710
@test unsafe fn testResolveOptionalVariantPayloadShapeErrors() throws (testing::TestError) {
1711
    try expectProgramError(
1712
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some => return 0, else => return 1 } }",
1713
        resolver::ErrorKind::UnionVariantPayloadMissing("Some")
1714
    );
1715
    try expectProgramError(
1716
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Nothing(_) => return 0, else => return 1 } }",
1717
        resolver::ErrorKind::UnionVariantPayloadUnexpected("Nothing")
1718
    );
1719
}
1720
1721
/// A match on an optional union is exhaustive when it names `nil` and every variant,
1722
/// for a payload union, a void union, and a reference to either.
1723
@test unsafe fn testResolveOptionalUnionVariantsWithNilOk() throws (testing::TestError) {
1724
    try expectProgramOk(
1725
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, case nil => return 2 } }"
1726
    );
1727
    try expectProgramOk(
1728
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case nil => return 2, case Other::Nothing => return 1, case Other::Some(x) => return x as i32 } }"
1729
    );
1730
    try expectProgramOk(
1731
        "union Color: Copy { Red, Green } fn f(c: ?Color) -> i32 { match c { case Color::Red => return 1, case Color::Green => return 2, case nil => return 0 } }"
1732
    );
1733
    try expectProgramOk(
1734
        "union Color: Copy { Red, Green } fn f(c: ?Color) -> i32 { match c { case Color::Red, Color::Green => return 1, case nil => return 0 } }"
1735
    );
1736
    try expectProgramOk(
1737
        "union Other: Copy { Some(u32), Nothing } fn f(o: &?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, case nil => return 2 } }"
1738
    );
1739
    try expectProgramOk(
1740
        "union Color: Copy { Red, Green } fn f(c: &?Color) -> i32 { match c { case Color::Red => return 1, case Color::Green => return 2, case nil => return 0 } }"
1741
    );
1742
}
1743
1744
/// A missing variant is rejected with the diagnostic of a plain union match, even when
1745
/// `nil` is present. The plain union match names the same variant.
1746
@test unsafe fn testResolveOptionalUnionMissingVariantError() throws (testing::TestError) {
1747
    try expectProgramError(
1748
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case nil => return 2 } }",
1749
        resolver::ErrorKind::UnionMatchNonExhaustive("Nothing")
1750
    );
1751
    try expectProgramError(
1752
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Nothing => return 1, case nil => return 2 } }",
1753
        resolver::ErrorKind::UnionMatchNonExhaustive("Some")
1754
    );
1755
    try expectProgramError(
1756
        "union Color: Copy { Red, Green } fn f(c: &?Color) -> i32 { match c { case Color::Red => return 1, case nil => return 0 } }",
1757
        resolver::ErrorKind::UnionMatchNonExhaustive("Green")
1758
    );
1759
    try expectProgramError(
1760
        "union Inner: Copy { A(u32), B } union Outer: Copy { Wrap(Inner), Done } fn f(o: ?Outer) -> i32 { match o { case Outer::Wrap(Inner::A(x)) => return 0, case Outer::Done => return 1, case nil => return 2 } }",
1761
        resolver::ErrorKind::UnionMatchNonExhaustive("Wrap")
1762
    );
1763
    try expectProgramError(
1764
        "union Other: Copy { Some(u32), Nothing } fn f(o: Other) -> i32 { match o { case Other::Some(_) => return 0 } }",
1765
        resolver::ErrorKind::UnionMatchNonExhaustive("Nothing")
1766
    );
1767
}
1768
1769
/// A missing `nil` is rejected with the optional diagnostic, also when every variant is named.
1770
/// A binding arm covers the present case in place of the variants.
1771
@test unsafe fn testResolveOptionalUnionMissingNilError() throws (testing::TestError) {
1772
    try expectProgramError(
1773
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1 } }",
1774
        resolver::ErrorKind::OptionalMatchMissingNil
1775
    );
1776
    try expectProgramError(
1777
        "union Color: Copy { Red, Green } fn f(c: &?Color) -> i32 { match c { case Color::Red, Color::Green => return 1 } }",
1778
        resolver::ErrorKind::OptionalMatchMissingNil
1779
    );
1780
    try expectProgramError(
1781
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, v => return 2 } }",
1782
        resolver::ErrorKind::OptionalMatchMissingNil
1783
    );
1784
    try expectProgramError(
1785
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0, case Other::Nothing => return 1, v => return 2, case nil => return 3 } }",
1786
        resolver::ErrorKind::UnreachableElse
1787
    );
1788
}
1789
1790
/// Variant arms without `nil` do not cover the absent case, so a match on an optional union
1791
/// that names only variants is rejected with the optional diagnostic.
1792
@test unsafe fn testResolveOptionalUnionVariantsWithoutNilError() throws (testing::TestError) {
1793
    try expectProgramError(
1794
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(_) => return 0 } }",
1795
        resolver::ErrorKind::OptionalMatchMissingValue
1796
    );
1797
}
1798
1799
/// A guarded variant arm does not cover its variant, as for a plain union. An unguarded arm
1800
/// for the same variant does.
1801
@test unsafe fn testResolveOptionalUnionGuardedVariantDoesNotCover() throws (testing::TestError) {
1802
    try expectProgramError(
1803
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(x) if x > 0 => return 0, case Other::Nothing => return 1, case nil => return 2 } }",
1804
        resolver::ErrorKind::UnionMatchNonExhaustive("Some")
1805
    );
1806
    try expectProgramOk(
1807
        "union Other: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Other::Some(x) if x > 0 => return 0, case Other::Some(_) => return 3, case Other::Nothing => return 1, case nil => return 2 } }"
1808
    );
1809
}
1810
1811
/// A call variant pattern of another union is rejected on an optional union subject.
1812
@test unsafe fn testResolveOptionalCallVariantOfOtherUnionMismatch() throws (testing::TestError) {
1813
    try expectUnionUnionMismatch(
1814
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Third::Some(_) => return 0, else => return 1 } }"
1815
    );
1816
}
1817
1818
/// A void variant pattern of another union is rejected on an optional union subject.
1819
@test unsafe fn testResolveOptionalScopeVariantOfOtherUnionMismatch() throws (testing::TestError) {
1820
    try expectUnionUnionMismatch(
1821
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { match o { case Third::Nothing => return 0, else => return 1 } }"
1822
    );
1823
}
1824
1825
/// A record-style variant pattern of another union is rejected on an optional union subject.
1826
@test unsafe fn testResolveOptionalRecordStyleVariantOfOtherUnionMismatch()
1827
    throws (testing::TestError)
1828
{
1829
    try expectUnionUnionMismatch(
1830
        "union Other: Copy { Some { value: u32 }, Nothing } union Third: Copy { Some { value: u32 }, Nothing } fn f(o: ?Other) -> i32 { match o { case Third::Some { value } => return value as i32, else => return 1 } }"
1831
    );
1832
}
1833
1834
/// A variant pattern of another union is rejected in `if let case`, `let case`, and `while let
1835
/// case`.
1836
@test unsafe fn testResolveOptionalVariantOfOtherUnionInConditionsMismatch()
1837
    throws (testing::TestError)
1838
{
1839
    try expectUnionUnionMismatch(
1840
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { if let case Third::Some(_) = o { return 0; } return 1; }"
1841
    );
1842
    try expectUnionUnionMismatch(
1843
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: ?Other) -> i32 { let case Third::Some(_) = o else return 1; return 0; }"
1844
    );
1845
    try expectUnionUnionMismatch(
1846
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: ?Other) { while let case Third::Some(_) = o { break; } }"
1847
    );
1848
}
1849
1850
/// A variant pattern of another union is rejected through a reference to an optional union.
1851
@test unsafe fn testResolveOptionalVariantOfOtherUnionThroughRefMismatch()
1852
    throws (testing::TestError)
1853
{
1854
    try expectUnionUnionMismatch(
1855
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } fn f(o: &?Other) -> i32 { match o { case Third::Some(_) => return 0, else => return 1 } }"
1856
    );
1857
}
1858
1859
/// A nested variant pattern of another union is rejected inside the payload of an optional union.
1860
@test unsafe fn testResolveOptionalNestedVariantOfOtherUnionMismatch() throws (testing::TestError) {
1861
    try expectUnionUnionMismatch(
1862
        "union Other: Copy { Some(u32), Nothing } union Third: Copy { Some(u32), Nothing } union Outer: Copy { Wrap(Other), Done } fn f(o: ?Outer) -> i32 { match o { case Outer::Wrap(Third::Some(_)) => return 0, else => return 1 } }"
1863
    );
1864
}
1865
1866
// Optional record patterns ////////////////////////////////////////////////////
1867
1868
/// Require the first error to be a mismatch between two different records.
1869
unsafe fn expectRecordRecordMismatch(program: *[u8]) throws (testing::TestError) {
1870
    let mut a = testResolver();
1871
    let result = try resolveProgramStr(&mut a, program);
1872
    let err = try expectError(&result);
1873
    let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
1874
        else throw testing::TestError::Failed;
1875
    let case resolver::Type::Nominal(expectedId) = mismatch.expected
1876
        else throw testing::TestError::Failed;
1877
    let case resolver::Type::Nominal(actualId) = mismatch.actual
1878
        else throw testing::TestError::Failed;
1879
    let case resolver::NominalType::Record(_) = a.nominals[*expectedId]
1880
        else throw testing::TestError::Failed;
1881
    let case resolver::NominalType::Record(_) = a.nominals[*actualId]
1882
        else throw testing::TestError::Failed;
1883
    try testing::expect(*expectedId <> *actualId);
1884
}
1885
1886
/// A record pattern with placeholders, literals, bindings, and a rest marker is accepted
1887
/// on an optional record subject.
1888
@test unsafe fn testResolveOptionalRecordPatternOk() throws (testing::TestError) {
1889
    try expectProgramOk(
1890
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: _, b: 4 } => return 1, else => return 0 } }"
1891
    );
1892
    try expectProgramOk(
1893
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 3, b: 4 } => return 1, case nil => return 2, _ => return 3 } }"
1894
    );
1895
    try expectProgramOk(
1896
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: 4 } => return a, case P { a: x, b: y } => return x + y, case nil => return 0 } }"
1897
    );
1898
    try expectProgramOk(
1899
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, .. } => return 1, case P { .. } => return 2, case nil => return 3 } }"
1900
    );
1901
    try expectProgramOk(
1902
        "record Q(u32, u32): Copy; fn f(q: ?Q) -> u32 { match q { case Q(1, _) => return 1, case Q(x, y) => return x + y, case nil => return 0 } }"
1903
    );
1904
    try expectProgramOk(
1905
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: _ } if a > 1 => return a, else => return 0 } }"
1906
    );
1907
    try expectProgramOk(
1908
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, b: _ }, P { a: 2, b: _ } => return 1, case P { .. }, nil => return 2 } }"
1909
    );
1910
}
1911
1912
/// A record pattern is accepted through references and inside records, and a nested
1913
/// record pattern is accepted on an optional record field.
1914
@test unsafe fn testResolveOptionalRecordPatternPlacesOk() throws (testing::TestError) {
1915
    try expectProgramOk(
1916
        "record P: Copy { a: u32, b: u32 } fn f(p: &?P) -> u32 { match p { case P { a, b: 4 } => return *a, else => return 0 } }"
1917
    );
1918
    try expectProgramOk(
1919
        "record P: Copy { a: u32, b: u32 } fn f(p: &mut ?P) { match p { case P { a, b: 4 } => set *a = 1, else => {} } }"
1920
    );
1921
    try expectProgramOk(
1922
        "record P: Copy { a: u32, b: u32 } record W: Copy { id: u32, p: ?P } fn f(w: W) -> u32 { match w { case W { id: _, p: P { a: _, b: 4 } } => return 1, case W { id, p: P { a, b: _ } } => return id + a, case W { p: nil, .. } => return 0, else => return 2 } }"
1923
    );
1924
}
1925
1926
/// A record pattern is accepted in `if let case`, `let case`, and `while let case` on an
1927
/// optional record subject.
1928
@test unsafe fn testResolveOptionalRecordPatternInConditionsOk() throws (testing::TestError) {
1929
    try expectProgramOk(
1930
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { if let case P { a: _, b: 4 } = p { return 1; } return 0; }"
1931
    );
1932
    try expectProgramOk(
1933
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { if let case P { a, b: 4 } = p; a > 1 { return a; } return 0; }"
1934
    );
1935
    try expectProgramOk(
1936
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { let case P { a, b: 4 } = p else return 0; return a; }"
1937
    );
1938
    try expectProgramOk(
1939
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) { while let case P { a: _, b: 4 } = p { break; } }"
1940
    );
1941
}
1942
1943
/// A record pattern binds its fields with the field types.
1944
@test unsafe fn testResolveOptionalRecordPatternBindsFieldType() throws (testing::TestError) {
1945
    try expectProgramOk(
1946
        "record P: Copy { a: u32, b: bool } fn f(p: ?P) -> u32 { match p { case P { a, b: _ } => { let y: u32 = a; return y; } else => return 0 } }"
1947
    );
1948
    try expectProgramError(
1949
        "record P: Copy { a: u32, b: bool } fn f(p: ?P) -> u32 { match p { case P { a, b: _ } => { let y: bool = a; return 0; } else => return 1 } }",
1950
        resolver::ErrorKind::TypeMismatch(resolver::TypeMismatch {
1951
            expected: resolver::Type::Bool, actual: resolver::Type::U32
1952
        })
1953
    );
1954
    try expectProgramError(
1955
        "record P: Copy { a: u32, b: bool } fn f(p: ?P) -> u32 { match p { case P { a: true, b: _ } => return 0, else => return 1 } }",
1956
        resolver::ErrorKind::TypeMismatch(resolver::TypeMismatch {
1957
            expected: resolver::Type::U32, actual: resolver::Type::Bool
1958
        })
1959
    );
1960
}
1961
1962
/// A record pattern of another record, an unknown field, and a wrong field count are
1963
/// rejected on an optional record subject.
1964
@test unsafe fn testResolveOptionalRecordPatternErrors() throws (testing::TestError) {
1965
    try expectRecordRecordMismatch(
1966
        "record P: Copy { a: u32 } record O: Copy { a: u32 } fn f(p: ?P) -> u32 { match p { case O { a: _ } => return 0, else => return 1 } }"
1967
    );
1968
    try expectRecordRecordMismatch(
1969
        "record P(u32): Copy; record O(u32): Copy; fn f(p: ?P) -> u32 { match p { case O(_) => return 0, else => return 1 } }"
1970
    );
1971
    try expectRecordRecordMismatch(
1972
        "record P: Copy { a: u32 } record O: Copy { a: u32 } fn f(p: ?P) -> u32 { if let case O { a: _ } = p { return 0; } return 1; }"
1973
    );
1974
    try expectProgramError(
1975
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: _, c: 4 } => return 0, else => return 1 } }",
1976
        resolver::ErrorKind::RecordFieldUnknown("c")
1977
    );
1978
    try expectProgramError(
1979
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: _ } => return 0, else => return 1 } }",
1980
        resolver::ErrorKind::RecordFieldCountMismatch(resolver::CountMismatch {
1981
            expected: 2, actual: 1
1982
        })
1983
    );
1984
    try expectProgramError(
1985
        "record Q(u32, u32): Copy; fn f(q: ?Q) -> u32 { match q { case Q(1) => return 0, else => return 1 } }",
1986
        resolver::ErrorKind::RecordFieldCountMismatch(resolver::CountMismatch {
1987
            expected: 2, actual: 1
1988
        })
1989
    );
1990
}
1991
1992
/// A prong with several alternatives cannot bind names, also for record patterns on an
1993
/// optional subject. Placeholders and literals are accepted.
1994
@test unsafe fn testResolveOptionalRecordPatternAlternatives() throws (testing::TestError) {
1995
    try expectProgramError(
1996
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: 1 }, P { a: 2, b: _ } => return 0, else => return 1 } }",
1997
        resolver::ErrorKind::AlternativeBinding
1998
    );
1999
    try expectProgramError(
2000
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, b: _ }, P { a: _, b } => return 0, else => return 1 } }",
2001
        resolver::ErrorKind::AlternativeBinding
2002
    );
2003
    try expectProgramError(
2004
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: _ }, nil => return 0, else => return 1 } }",
2005
        resolver::ErrorKind::AlternativeBinding
2006
    );
2007
    try expectProgramOk(
2008
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, b: _ }, P { a: 2, b: _ } => return 0, else => return 1 } }"
2009
    );
2010
}
2011
2012
/// A match on an optional record is exhaustive when an unguarded record pattern without
2013
/// refining sub-patterns and `nil` are named, as for a union with every variant.
2014
@test unsafe fn testResolveOptionalRecordPatternExhaustive() throws (testing::TestError) {
2015
    try expectProgramOk(
2016
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: _ } => return a, case nil => return 0 } }"
2017
    );
2018
    try expectProgramOk(
2019
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case nil => return 0, case P { .. } => return 1 } }"
2020
    );
2021
    try expectProgramOk(
2022
        "record Q(u32, u32): Copy; fn f(q: ?Q) -> u32 { match q { case Q(_, _) => return 1, case nil => return 0 } }"
2023
    );
2024
    try expectProgramOk(
2025
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, b: _ } => return 1, case P { a: _, b: _ } => return 2, case nil => return 0 } }"
2026
    );
2027
    try expectProgramOk(
2028
        "record P: Copy { a: u32, b: u32 } fn f(p: &?P) -> u32 { match p { case P { .. } => return 1, case nil => return 0 } }"
2029
    );
2030
    try expectProgramOk(
2031
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { .. }, nil => return 1 } }"
2032
    );
2033
}
2034
2035
/// A refining or guarded record pattern does not cover the present case.
2036
@test unsafe fn testResolveOptionalRecordPatternNotExhaustive() throws (testing::TestError) {
2037
    try expectProgramError(
2038
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: 1, b: _ } => return 1, case nil => return 0 } }",
2039
        resolver::ErrorKind::OptionalMatchMissingValue
2040
    );
2041
    try expectProgramError(
2042
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a, b: _ } if a > 1 => return 1, case nil => return 0 } }",
2043
        resolver::ErrorKind::OptionalMatchMissingValue
2044
    );
2045
    try expectProgramError(
2046
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { a: _, b: _ } => return 1 } }",
2047
        resolver::ErrorKind::OptionalMatchMissingNil
2048
    );
2049
    try expectProgramError(
2050
        "record P: Copy { a: u32, b: u32 } record W: Copy { p: ?P } fn f(w: ?W) -> u32 { match w { case W { p: P { .. } } => return 1, case nil => return 0 } }",
2051
        resolver::ErrorKind::OptionalMatchMissingValue
2052
    );
2053
}
2054
2055
/// An `else` after a covering record pattern and `nil`, and a second covering record
2056
/// pattern, are rejected.
2057
@test unsafe fn testResolveOptionalRecordPatternUnreachable() throws (testing::TestError) {
2058
    try expectProgramError(
2059
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { .. } => return 1, case nil => return 0, else => return 2 } }",
2060
        resolver::ErrorKind::UnreachableElse
2061
    );
2062
    try expectProgramError(
2063
        "record P: Copy { a: u32, b: u32 } fn f(p: ?P) -> u32 { match p { case P { .. } => return 1, case P { a: _, b: _ } => return 2, case nil => return 0 } }",
2064
        resolver::ErrorKind::DuplicateMatchPattern
2065
    );
2066
}
2067
2068
/// Test that function pointers with identical signatures are assignable.
2069
///
2070
/// Two function types with the same parameters, return type, and throw list
2071
/// should be considered structurally equal, even if they are separate allocations.
2072
@test unsafe fn testFnPointerAssignability() throws (testing::TestError) {
2073
    let mut a = testResolver();
2074
    let program =
2075
        "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn double(n: i32) -> i32 { return n * 2; } apply(double, 5);";
2076
    let result = try resolveProgramStr(&mut a, program);
2077
    try expectNoErrors(&result);
2078
}
2079
2080
/// Test that function pointers with different parameter types are not assignable.
2081
@test unsafe fn testFnPointerParamMismatch() throws (testing::TestError) {
2082
    let mut a = testResolver();
2083
    let program =
2084
        "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
2085
    let result = try resolveProgramStr(&mut a, program);
2086
    let err = try expectError(&result);
2087
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2088
}
2089
2090
/// Test that function pointers with different return types are not assignable.
2091
@test unsafe fn testFnPointerReturnMismatch() throws (testing::TestError) {
2092
    let mut a = testResolver();
2093
    let program =
2094
        "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
2095
    let result = try resolveProgramStr(&mut a, program);
2096
    let err = try expectError(&result);
2097
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2098
}
2099
2100
/// Test that named records use nominal typing, not structural.
2101
///
2102
/// Two different named record types with identical fields should NOT be
2103
/// assignable to each other, because they are distinct nominal types.
2104
@test unsafe fn testNamedRecordNominalTyping() throws (testing::TestError) {
2105
    let mut a = testResolver();
2106
    let program =
2107
        "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
2108
    let result = try resolveProgramStr(&mut a, program);
2109
    let err = try expectError(&result);
2110
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2111
}
2112
2113
/// Test that union variants with labeled record payloads can be constructed.
2114
@test unsafe fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
2115
    let mut a = testResolver();
2116
    let program =
2117
        "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
2118
    let result = try resolveProgramStr(&mut a, program);
2119
    try expectNoErrors(&result);
2120
}
2121
2122
/// Test that unlabeled record literals with positional fields work correctly.
2123
///
2124
/// When a record is declared with positional fields (e.g., `record R(i32, bool)`),
2125
/// the literal must use constructor call syntax with positional arguments.
2126
@test unsafe fn testResolveUnlabeledRecordLitValid() throws (testing::TestError) {
2127
    let mut a = testResolver();
2128
    let program = "record R(i32, bool); let r: R = R(1, true);";
2129
    let result = try resolveProgramStr(&mut a, program);
2130
    try expectNoErrors(&result);
2131
}
2132
2133
/// Test that using brace syntax for an unlabeled record causes an error.
2134
@test unsafe fn testResolveUnlabeledRecordLitStyleMismatch() throws (testing::TestError) {
2135
    let mut a = testResolver();
2136
    let program = "record R(i32); let r = R { x: 1 };";
2137
    let result = try resolveProgramStr(&mut a, program);
2138
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldStyleMismatch);
2139
}
2140
2141
/// Test that providing too many fields for an unlabeled record causes count mismatch.
2142
@test unsafe fn testResolveUnlabeledRecordLitTooManyFields() throws (testing::TestError) {
2143
    let mut a = testResolver();
2144
    let program = "record R(i32, bool); let r = R(1, true, 3);";
2145
    let result = try resolveProgramStr(&mut a, program);
2146
    let err = try expectError(&result);
2147
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2148
        else throw testing::TestError::Failed;
2149
}
2150
2151
/// Test that match pattern with wrong number of bindings causes count mismatch.
2152
@test unsafe fn testResolveMatchPatternWrongBindingCount() throws (testing::TestError) {
2153
    let mut a = testResolver();
2154
    let program =
2155
        "union Event { Click { x: i32, y: i32 } } fn f(e: Event) { match e { case Event::Click(a) => {} } }";
2156
    let result = try resolveProgramStr(&mut a, program);
2157
    let err = try expectError(&result);
2158
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2159
        else throw testing::TestError::Failed;
2160
}
2161
2162
/// Test that shorthand field syntax works in record literals.
2163
/// `Point { x, y }` should be equivalent to `Point { x: x, y: y }`.
2164
@test unsafe fn testResolveRecordLiteralShorthand() throws (testing::TestError) {
2165
    let mut a = testResolver();
2166
    let program =
2167
        "record Point { x: i32, y: i32 } fn f() { let x: i32 = 1; let y: i32 = 2; let p = Point { x, y }; }";
2168
    let result = try resolveProgramStr(&mut a, program);
2169
    try expectNoErrors(&result);
2170
}
2171
2172
/// Test shorthand field syntax with mixed explicit and shorthand fields.
2173
@test unsafe fn testResolveRecordLiteralMixedShorthand() throws (testing::TestError) {
2174
    let mut a = testResolver();
2175
    let program =
2176
        "record Point { x: i32, y: i32 } fn f() { let x: i32 = 5; let p = Point { x, y: 10 }; }";
2177
    let result = try resolveProgramStr(&mut a, program);
2178
    try expectNoErrors(&result);
2179
}
2180
2181
/// Test record-style union variant patterns with shorthand syntax.
2182
@test unsafe fn testResolveMatchRecordPatternShorthand() throws (testing::TestError) {
2183
    let mut a = testResolver();
2184
    let program =
2185
        "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height } => return width + height } }";
2186
    let result = try resolveProgramStr(&mut a, program);
2187
    try expectNoErrors(&result);
2188
}
2189
2190
/// Test record pattern with mixed shorthand and explicit labels.
2191
@test unsafe fn testResolveMatchRecordPatternMixed() throws (testing::TestError) {
2192
    let mut a = testResolver();
2193
    let program =
2194
        "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { width, height: h } => return width + h } }";
2195
    let result = try resolveProgramStr(&mut a, program);
2196
    try expectNoErrors(&result);
2197
}
2198
2199
/// Test record pattern with fields in reverse order.
2200
@test unsafe fn testResolveMatchRecordPatternReversed() throws (testing::TestError) {
2201
    let mut a = testResolver();
2202
    let program =
2203
        "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height: h, width: w } => return w + h } }";
2204
    let result = try resolveProgramStr(&mut a, program);
2205
    try expectNoErrors(&result);
2206
}
2207
2208
/// Test record pattern with shorthand syntax in reverse order.
2209
/// Pattern `{ height, width }` binds all fields using shorthand, but not in definition order.
2210
@test unsafe fn testResolveMatchRecordPatternShorthandReversed() throws (testing::TestError) {
2211
    let mut a = testResolver();
2212
    let program =
2213
        "union Shape { Rect { width: i32, height: i32 } } fn f(s: Shape) -> i32 { match s { case Shape::Rect { height, width } => return width + height } }";
2214
    let result = try resolveProgramStr(&mut a, program);
2215
    try expectNoErrors(&result);
2216
}
2217
2218
/// Test record pattern with `..` ignoring fields.
2219
@test unsafe fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
2220
    {
2221
        let mut a = testResolver();
2222
        let program =
2223
            "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x, .. } => return x } }";
2224
        let result = try resolveProgramStr(&mut a, program);
2225
        try expectNoErrors(&result);
2226
    }
2227
    {
2228
        let mut a = testResolver();
2229
        let program =
2230
            "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { x: val, .. } => return val } }";
2231
        let result = try resolveProgramStr(&mut a, program);
2232
        try expectNoErrors(&result);
2233
    }
2234
    {
2235
        let mut a = testResolver();
2236
        let program =
2237
            "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, .. } => return z } }";
2238
        let result = try resolveProgramStr(&mut a, program);
2239
        try expectNoErrors(&result);
2240
    }
2241
    {
2242
        let mut a = testResolver();
2243
        let program =
2244
            "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> i32 { match g { case G::Point { z, x, .. } => return x + z } }";
2245
        let result = try resolveProgramStr(&mut a, program);
2246
        try expectNoErrors(&result);
2247
    }
2248
    {
2249
        let mut a = testResolver();
2250
        let program =
2251
            "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> bool { match g { case G::Point { .. } => return true } }";
2252
        let result = try resolveProgramStr(&mut a, program);
2253
        try expectNoErrors(&result);
2254
    }
2255
}
2256
2257
/// Test standalone record pattern matching with unlabeled patterns.
2258
@test unsafe fn testResolveMatchStandaloneRecordUnlabeledPattern() throws (testing::TestError) {
2259
    let mut a = testResolver();
2260
    let program =
2261
        "record S(i32); fn f(s: S) -> i32 { match s { case S(x) => return x, else => return 0 } }";
2262
    let result = try resolveProgramStr(&mut a, program);
2263
    try expectNoErrors(&result);
2264
}
2265
2266
/// Test standalone record pattern matching with labeled patterns.
2267
/// Pattern syntax: `T { x }` matches a named record and binds x to the field.
2268
@test unsafe fn testResolveMatchStandaloneRecordLabeledPattern() throws (testing::TestError) {
2269
    let mut a = testResolver();
2270
    let program =
2271
        "record T { x: i32 } fn f(t: T) -> i32 { match t { case T { x } => return x, else => return 0 } }";
2272
    let result = try resolveProgramStr(&mut a, program);
2273
    try expectNoErrors(&result);
2274
}
2275
2276
/// Test standalone record pattern with multiple fields.
2277
/// Pattern syntax: `R(a, b)` matches an unlabeled record with multiple fields.
2278
@test unsafe fn testResolveMatchStandaloneRecordMultipleFields() throws (testing::TestError) {
2279
    let mut a = testResolver();
2280
    let program =
2281
        "record R(bool, u8); fn f(r: R) -> u8 { match r { case R(_, x) => return x, else => return 0 } }";
2282
    let result = try resolveProgramStr(&mut a, program);
2283
    try expectNoErrors(&result);
2284
}
2285
2286
/// Test standalone record pattern with wrong field count.
2287
/// Pattern `S(x, y)` should fail for a single-field record.
2288
@test unsafe fn testResolveMatchStandaloneRecordWrongFieldCount() throws (testing::TestError) {
2289
    let mut a = testResolver();
2290
    let program =
2291
        "record S(i32); fn f(s: S) -> i32 { match s { case S(x, y) => return x + y, else => return 0 } }";
2292
    let result = try resolveProgramStr(&mut a, program);
2293
    let err = try expectError(&result);
2294
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2295
        else throw testing::TestError::Failed;
2296
}
2297
2298
/// Test array pattern matching with element bindings.
2299
/// Pattern syntax: `[x, y]` matches an array and binds elements.
2300
@test unsafe fn testResolveMatchArrayPattern() throws (testing::TestError) {
2301
    let mut a = testResolver();
2302
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [x, y] => return x + y } }";
2303
    let result = try resolveProgramStr(&mut a, program);
2304
    try expectNoErrors(&result);
2305
}
2306
2307
/// Test array pattern with placeholder elements.
2308
/// Pattern syntax: `[_, y]` ignores first element.
2309
@test unsafe fn testResolveMatchArrayPatternPlaceholder() throws (testing::TestError) {
2310
    let mut a = testResolver();
2311
    let program = "fn f(arr: [i32; 2]) -> i32 { match arr { case [_, y] => return y } }";
2312
    let result = try resolveProgramStr(&mut a, program);
2313
    try expectNoErrors(&result);
2314
}
2315
2316
/// Placeholders in value positions are rejected.
2317
@test unsafe fn testResolvePlaceholderValueRejected() throws (testing::TestError) {
2318
    let programs = &[
2319
        "fn f() -> u32 { let x: u32 = _; return x; }",
2320
        "fn f() -> u32 { return _; }",
2321
        "fn take(value: u32) {} fn f() { take(_); }",
2322
        "fn f() -> u32 { return 1 + _; }",
2323
        "fn f() -> u32 { return _ + 1; }",
2324
        "record R: Copy { value: u32 } fn f() { let r = R { value: _ }; }",
2325
        "fn f() { let a: [u32; 1] = [_]; }",
2326
        "fn f() { let mut x: u32 = 0; set x = _; }",
2327
    ];
2328
    for program in programs {
2329
        let mut a = testResolver();
2330
        let result = try resolveProgramStr(&mut a, program);
2331
        try expectErrorKind(&result, resolver::ErrorKind::PlaceholderExpression);
2332
    }
2333
}
2334
2335
/// Placeholders in binding and pattern positions are accepted.
2336
@test unsafe fn testResolvePlaceholderPatternAccepted() throws (testing::TestError) {
2337
    let programs = &[
2338
        "fn f() { let _ = 1 as u32; }",
2339
        "fn f(arr: [u32; 1]) { for _ in arr {} }",
2340
        "union U: Copy { Value(u32) } fn f(u: U) -> bool { match u { case U::Value(_) => return true } }",
2341
        "union U: Copy { Value(u32) } fn f(u: &?U) -> bool { match u { case U::Value(_) => return true, else => return false } }",
2342
        "record R: Copy { a: u32, b: u32 } fn f(r: R) -> u32 { match r { case R { a, b: _ } => return a, else => return 0 } }",
2343
        "fn f(arr: [u32; 2]) -> u32 { match arr { case [_, y] => return y } }",
2344
    ];
2345
    for program in programs {
2346
        let mut a = testResolver();
2347
        let result = try resolveProgramStr(&mut a, program);
2348
        try expectNoErrors(&result);
2349
    }
2350
}
2351
2352
/// Test identifier pattern that binds the whole value.
2353
/// Pattern syntax: `x` matches any value and binds it.
2354
@test unsafe fn testResolveMatchIdentPattern() throws (testing::TestError) {
2355
    let mut a = testResolver();
2356
    let program = "fn f(val: i32) -> i32 { match val { x => return x } }";
2357
    let result = try resolveProgramStr(&mut a, program);
2358
    try expectNoErrors(&result);
2359
}
2360
2361
/// Test numeric literal pattern matching.
2362
@test unsafe fn testResolveMatchNumericLiteralPattern() throws (testing::TestError) {
2363
    let mut a = testResolver();
2364
    let program = "fn f(val: i32) -> i32 { match val { case 42 => return 1, else => return 0 } }";
2365
    let result = try resolveProgramStr(&mut a, program);
2366
    try expectNoErrors(&result);
2367
}
2368
2369
/// Test string literal pattern matching.
2370
@test unsafe fn testResolveMatchStringLiteralPattern() throws (testing::TestError) {
2371
    let mut a = testResolver();
2372
    let program =
2373
        "fn f(val: *[u8]) -> i32 { match val { case \"hello\" => return 1, else => return 0 } }";
2374
    let result = try resolveProgramStr(&mut a, program);
2375
    try expectNoErrors(&result);
2376
}
2377
2378
/// Test boolean literal pattern matching.
2379
@test unsafe fn testResolveMatchBoolLiteralPattern() throws (testing::TestError) {
2380
    let mut a = testResolver();
2381
    let program =
2382
        "fn f(val: bool) -> i32 { match val { case true => return 1, case false => return 0 } }";
2383
    let result = try resolveProgramStr(&mut a, program);
2384
    try expectNoErrors(&result);
2385
}
2386
2387
/// Test @sliceOf with correct arguments succeeds.
2388
@test unsafe fn testResolveSliceOfCorrect() throws (testing::TestError) {
2389
    // Immutable pointer.
2390
    {
2391
        let mut a = testResolver();
2392
        let program = "unsafe fn f(ptr: *u8, len: u32) -> *[u8] { return @sliceOf(ptr, len); }";
2393
        let result = try resolveProgramStr(&mut a, program);
2394
        try expectNoErrors(&result);
2395
    }
2396
    // Mutable pointer produces mutable slice.
2397
    {
2398
        let mut a = testResolver();
2399
        let program =
2400
            "unsafe fn f(ptr: *mut u8, len: u32) -> *mut [u8] { return @sliceOf(ptr, len); }";
2401
        let result = try resolveProgramStr(&mut a, program);
2402
        try expectNoErrors(&result);
2403
    }
2404
}
2405
2406
/// Test @sliceOf with wrong argument count produces an error.
2407
@test unsafe fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
2408
    // No arguments.
2409
    {
2410
        let mut a = testResolver();
2411
        let program = "fn f() -> *[u8] { return @sliceOf(); }";
2412
        let result = try resolveProgramStr(&mut a, program);
2413
        let err = try expectError(&result);
2414
        let case resolver::ErrorKind::Builtin(resolver::BuiltinError::ArgCount(mismatch)) = err.kind
2415
            else throw testing::TestError::Failed;
2416
        try testing::expect(mismatch.expected == 2);
2417
        try testing::expect(mismatch.actual == 0);
2418
    }
2419
    // Too few arguments.
2420
    {
2421
        let mut a = testResolver();
2422
        let program = "fn f(ptr: *u8) -> *[u8] { return @sliceOf(ptr); }";
2423
        let result = try resolveProgramStr(&mut a, program);
2424
        let err = try expectError(&result);
2425
        let case resolver::ErrorKind::Builtin(resolver::BuiltinError::ArgCount(mismatch)) = err.kind
2426
            else throw testing::TestError::Failed;
2427
        try testing::expect(mismatch.expected == 2);
2428
        try testing::expect(mismatch.actual == 1);
2429
    }
2430
    // Too many arguments.
2431
    {
2432
        let mut a = testResolver();
2433
        let program =
2434
            "fn f(ptr: *u8, len: u32, cap: u32, extra: u32) -> *[u8] { return @sliceOf(ptr, len, cap, extra); }";
2435
        let result = try resolveProgramStr(&mut a, program);
2436
        let err = try expectError(&result);
2437
        let case resolver::ErrorKind::Builtin(resolver::BuiltinError::ArgCount(mismatch)) = err.kind
2438
            else throw testing::TestError::Failed;
2439
        try testing::expect(mismatch.expected == 2);
2440
        try testing::expect(mismatch.actual == 4);
2441
    }
2442
}
2443
2444
/// Test @sliceOf with wrong argument types produces errors.
2445
@test unsafe fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
2446
    // Non-pointer first argument.
2447
    {
2448
        let mut a = testResolver();
2449
        let program = "fn f(val: u32, len: u32) -> *[u8] { return @sliceOf(val, len); }";
2450
        let result = try resolveProgramStr(&mut a, program);
2451
        let err = try expectError(&result);
2452
        let case resolver::ErrorKind::ExpectedPointer = err.kind
2453
            else throw testing::TestError::Failed;
2454
    }
2455
    // Array instead of pointer.
2456
    {
2457
        let mut a = testResolver();
2458
        let program = "fn f(arr: [u8; 4], len: u32) -> *[u8] { return @sliceOf(arr, len); }";
2459
        let result = try resolveProgramStr(&mut a, program);
2460
        let err = try expectError(&result);
2461
        let case resolver::ErrorKind::ExpectedPointer = err.kind
2462
            else throw testing::TestError::Failed;
2463
    }
2464
    // Non-numeric second argument.
2465
    {
2466
        let mut a = testResolver();
2467
        let program = "fn f(ptr: *u8, len: bool) -> *[u8] { return @sliceOf(ptr, len); }";
2468
        let result = try resolveProgramStr(&mut a, program);
2469
        let err = try expectError(&result);
2470
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2471
            else throw testing::TestError::Failed;
2472
    }
2473
    // Pointer second argument.
2474
    {
2475
        let mut a = testResolver();
2476
        let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
2477
        let result = try resolveProgramStr(&mut a, program);
2478
        let err = try expectError(&result);
2479
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2480
            else throw testing::TestError::Failed;
2481
    }
2482
}
2483
2484
/// Test @sliceOf with 3 arguments (ptr, len, cap) succeeds.
2485
@test unsafe fn testResolveSliceOfWithCap() throws (testing::TestError) {
2486
    {
2487
        let mut a = testResolver();
2488
        let program =
2489
            "unsafe fn f(ptr: *u8, len: u32, cap: u32) -> *[u8] { return @sliceOf(ptr, len, cap); }";
2490
        let result = try resolveProgramStr(&mut a, program);
2491
        try expectNoErrors(&result);
2492
    }
2493
    // Mutable pointer produces mutable slice.
2494
    {
2495
        let mut a = testResolver();
2496
        let program =
2497
            "unsafe fn f(ptr: *mut u8, len: u32, cap: u32) -> *mut [u8] { return @sliceOf(ptr, len, cap); }";
2498
        let result = try resolveProgramStr(&mut a, program);
2499
        try expectNoErrors(&result);
2500
    }
2501
}
2502
2503
/// Test @sliceOf with 3 arguments but wrong cap type.
2504
@test unsafe fn testResolveSliceOfCapWrongType() throws (testing::TestError) {
2505
    let mut a = testResolver();
2506
    let program =
2507
        "fn f(ptr: *u8, len: u32, cap: bool) -> *[u8] { return @sliceOf(ptr, len, cap); }";
2508
    let result = try resolveProgramStr(&mut a, program);
2509
    let err = try expectError(&result);
2510
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2511
}
2512
2513
/// Test .cap field access on slices resolves to u32.
2514
@test unsafe fn testResolveSliceCapField() throws (testing::TestError) {
2515
    let mut a = testResolver();
2516
    let program = "fn f(s: *[u8]) -> u32 { return s.cap; }";
2517
    let result = try resolveProgramStr(&mut a, program);
2518
    try expectNoErrors(&result);
2519
}
2520
2521
/// Test `.append()` on immutable slice produces an error.
2522
@test unsafe fn testResolveSliceAppendImmutable() throws (testing::TestError) {
2523
    let mut a = testResolver();
2524
    let program =
2525
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *[i32], a: &Heap) { try! s.append(1, a); }";
2526
    let result = try resolveProgramStr(&mut a, program);
2527
    let err = try expectError(&result);
2528
    let case resolver::ErrorKind::SliceNotMutable = err.kind else throw testing::TestError::Failed;
2529
}
2530
2531
/// Test `.append()` with wrong argument count produces an error.
2532
@test unsafe fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
2533
    // Too few arguments.
2534
    {
2535
        let mut a = testResolver();
2536
        let program = "fn f(owned: *mut [i32]) { let mut s = owned; try! s.append(1); }";
2537
        let result = try resolveProgramStr(&mut a, program);
2538
        let err = try expectError(&result);
2539
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2540
            else throw testing::TestError::Failed;
2541
        try testing::expect(m.expected == 2);
2542
        try testing::expect(m.actual == 1);
2543
    }
2544
    // Too many arguments.
2545
    {
2546
        let mut a = testResolver();
2547
        let program =
2548
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.append(1, a, 0); }";
2549
        let result = try resolveProgramStr(&mut a, program);
2550
        let err = try expectError(&result);
2551
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2552
            else throw testing::TestError::Failed;
2553
        try testing::expect(m.expected == 2);
2554
        try testing::expect(m.actual == 3);
2555
    }
2556
}
2557
2558
/// The prefix of the programs that test `new`: the heap types and a record type.
2559
constant NEW_PROGRAM: *[u8] =
2560
    "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record P: Copy { x: u32 } ";
2561
2562
/// Resolve `NEW_PROGRAM` followed by `rest`.
2563
unsafe fn resolveNew(a: &mut resolver::Resolver, rest: *[u8]) -> TestResult
2564
    throws (testing::TestError)
2565
{
2566
    let mut program: *mut [u8] = &mut [];
2567
    try! program.extend(NEW_PROGRAM, a.arena);
2568
    try! program.extend(rest, a.arena);
2569
    return try resolveProgramStr(a, &program[..]);
2570
}
2571
2572
/// `new` allocates from a heap handle, and its result is an owned mutable pointer.
2573
@test unsafe fn testResolveAllocNew() throws (testing::TestError) {
2574
    let programs: [*[u8]; 1] = [
2575
        "fn f(a: &Heap) -> *mut P throws (AllocError) { return try a.new(P { x: 1 }); }"
2576
    ];
2577
    for program in programs {
2578
        let mut a = testResolver();
2579
        let result = try resolveNew(&mut a, program);
2580
        try expectNoErrors(&result);
2581
    }
2582
}
2583
2584
/// `new` needs `try`, one argument, and a heap receiver.
2585
@test unsafe fn testResolveAllocNewErrors() throws (testing::TestError) {
2586
    {
2587
        let mut a = testResolver();
2588
        let result = try resolveNew(
2589
            &mut a, "fn f(a: &Heap) throws (AllocError) { let p = a.new(P { x: 1 }); }"
2590
        );
2591
        let err = try expectError(&result);
2592
        let case resolver::ErrorKind::MissingTry = err.kind else throw testing::TestError::Failed;
2593
    }
2594
    {
2595
        let mut a = testResolver();
2596
        let result = try resolveNew(
2597
            &mut a, "fn f(a: &Heap) throws (AllocError) { let p = try a.new(P { x: 1 }, 2); }"
2598
        );
2599
        let err = try expectError(&result);
2600
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2601
            else throw testing::TestError::Failed;
2602
        try testing::expect(m.expected == 1 and m.actual == 2);
2603
    }
2604
    {
2605
        let mut a = testResolver();
2606
        let result = try resolveNew(
2607
            &mut a, "fn f(p: &mut P) throws (AllocError) { let q = try p.new(P { x: 1 }); }"
2608
        );
2609
        let err = try expectError(&result);
2610
        let case resolver::ErrorKind::RecordFieldUnknown(_) = err.kind
2611
            else throw testing::TestError::Failed;
2612
    }
2613
}
2614
2615
/// Test `.append()` with correct arguments succeeds.
2616
@test unsafe fn testResolveSliceAppendCorrect() throws (testing::TestError) {
2617
    let mut a = testResolver();
2618
    let program =
2619
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.append(1, a); }";
2620
    let result = try resolveProgramStr(&mut a, program);
2621
    try expectNoErrors(&result);
2622
}
2623
2624
/// Test `.append()` with wrong element type produces an error.
2625
@test unsafe fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
2626
    let mut a = testResolver();
2627
    let program =
2628
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.append(true, a); }";
2629
    let result = try resolveProgramStr(&mut a, program);
2630
    let err = try expectError(&result);
2631
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2632
}
2633
2634
/// `let case` binds fields of a reference scrutinee by reference, as `if let case` does.
2635
@test unsafe fn testLetCaseRefBinding() throws (testing::TestError) {
2636
    {
2637
        let program =
2638
            "record Pair(i32, bool): Copy; fn f(p: &Pair) -> i32 { let case Pair(n, _) = p else return -1; return n; }";
2639
        let mut a = testResolver();
2640
        let result = try resolveProgramStr(&mut a, program);
2641
        let err = try expectError(&result);
2642
        let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
2643
            else throw testing::TestError::Failed;
2644
        try testing::expect(mismatch.expected == resolver::Type::I32);
2645
        let target = try expectPointerType(mismatch.actual, false);
2646
        try testing::expect(target == resolver::Type::I32);
2647
    }
2648
    try expectAnalyzeOk(
2649
        "record Pair(i32, bool): Copy; fn f(p: &Pair) -> i32 { let case Pair(n, _) = p else return -1; return *n; }"
2650
    );
2651
    try expectAnalyzeOk(
2652
        "record Pair(i32, bool): Copy; fn g(p: &mut Pair) { let case Pair(n, _) = p else return; set *n = 1; }"
2653
    );
2654
}
2655
2656
/// `*r` on a single-field positional record denotes field 0, and only a mutable binding can write
2657
/// it.
2658
@test unsafe fn testDerefSingleFieldRecord() throws (testing::TestError) {
2659
    try expectAnalyzeOk("record NodeId(u32): Copy; fn f(id: NodeId) -> u32 { return *id; }");
2660
    try expectAnalyzeOk("record NodeId(u32): Copy; fn f(p: &NodeId) -> u32 { return **p; }");
2661
    try expectAnalyzeOk("record NodeId(u32): Copy; fn f(p: &mut NodeId) { set *p = NodeId(2); }");
2662
    try expectAnalyzeOk(
2663
        "record NodeId(u32): Copy; fn f() { let mut id = NodeId(1); set *id = 4; }"
2664
    );
2665
    {
2666
        let mut a = testResolver();
2667
        let result = try resolveProgramStr(
2668
            &mut a, "record NodeId(bool): Copy; fn f(id: NodeId) -> u32 { return *id; }"
2669
        );
2670
        let err = try expectError(&result);
2671
        let case resolver::ErrorKind::TypeMismatch(mismatch) = err.kind
2672
            else throw testing::TestError::Failed;
2673
        try testing::expect(mismatch.expected == resolver::Type::U32);
2674
        try testing::expect(mismatch.actual == resolver::Type::Bool);
2675
    }
2676
    {
2677
        let mut a = testResolver();
2678
        let result = try resolveProgramStr(
2679
            &mut a, "record NodeId(u32): Copy; fn f() { let id = NodeId(1); set *id = 4; }"
2680
        );
2681
        try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
2682
    }
2683
    {
2684
        let mut a = testResolver();
2685
        let result = try resolveProgramStr(
2686
            &mut a, "record Lab: Copy { a: u32 } fn f(r: Lab) -> u32 { return *r; }"
2687
        );
2688
        try expectErrorKind(&result, resolver::ErrorKind::DerefLabeledRecord);
2689
    }
2690
    {
2691
        let mut b = testResolver();
2692
        let result2 = try resolveProgramStr(
2693
            &mut b, "record Two(u32, u32): Copy; fn f(r: Two) -> u32 { return *r; }"
2694
        );
2695
        try expectErrorKind(&result2, resolver::ErrorKind::DerefRecordFieldCount);
2696
    }
2697
    {
2698
        let mut c = testResolver();
2699
        let result3 = try resolveProgramStr(&mut c, "record Zero(): Copy; fn f(r: Zero) { *r; }");
2700
        try expectErrorKind(&result3, resolver::ErrorKind::DerefRecordFieldCount);
2701
    }
2702
}
2703
2704
/// Test `.reserve()` rejects bad receivers and arguments.
2705
@test unsafe fn testResolveSliceReserveRejected() throws (testing::TestError) {
2706
    {
2707
        let mut a = testResolver();
2708
        let program =
2709
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *[i32], a: &Heap) { try! s.reserve(1, a); }";
2710
        let result = try resolveProgramStr(&mut a, program);
2711
        let err = try expectError(&result);
2712
        let case resolver::ErrorKind::SliceNotMutable = err.kind
2713
            else throw testing::TestError::Failed;
2714
    }
2715
    {
2716
        let mut a = testResolver();
2717
        let program =
2718
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.reserve(true, a); }";
2719
        let result = try resolveProgramStr(&mut a, program);
2720
        let err = try expectError(&result);
2721
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2722
            else throw testing::TestError::Failed;
2723
    }
2724
    {
2725
        let mut a = testResolver();
2726
        let program =
2727
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(x: u32, a: &Heap) { try! x.reserve(1, a); }";
2728
        let result = try resolveProgramStr(&mut a, program);
2729
        let err = try expectError(&result);
2730
    }
2731
    {
2732
        let mut a = testResolver();
2733
        let program =
2734
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(arr: [i32; 4], a: &Heap) { try! arr.reserve(1, a); }";
2735
        let result = try resolveProgramStr(&mut a, program);
2736
        let err = try expectError(&result);
2737
    }
2738
}
2739
2740
/// Test `.resize()` rejects bad receivers, counts, values, and element types.
2741
@test unsafe fn testResolveSliceResizeRejected() throws (testing::TestError) {
2742
    {
2743
        let mut a = testResolver();
2744
        let program =
2745
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *[i32], a: &Heap) { try! s.resize(4, 1, a); }";
2746
        let result = try resolveProgramStr(&mut a, program);
2747
        try expectErrorKind(&result, resolver::ErrorKind::SliceNotMutable);
2748
    }
2749
    {
2750
        let mut a = testResolver();
2751
        let program =
2752
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.resize(4, a); }";
2753
        let result = try resolveProgramStr(&mut a, program);
2754
        let err = try expectError(&result);
2755
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2756
            else throw testing::TestError::Failed;
2757
        try testing::expect(m.expected == 3);
2758
        try testing::expect(m.actual == 2);
2759
    }
2760
    {
2761
        let mut a = testResolver();
2762
        let program =
2763
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record N { x: i32 } fn f(owned: *mut [N], a: &Heap) { let mut s = owned; try! s.resize(1, N { x: 1 }, a); }";
2764
        let result = try resolveProgramStr(&mut a, program);
2765
        try expectErrorKind(&result, resolver::ErrorKind::SliceElemNotCopy);
2766
    }
2767
    {
2768
        let mut a = testResolver();
2769
        let program =
2770
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.resize(4, true, a); }";
2771
        let result = try resolveProgramStr(&mut a, program);
2772
        let err = try expectError(&result);
2773
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2774
            else throw testing::TestError::Failed;
2775
    }
2776
    {
2777
        let mut a = testResolver();
2778
        let program =
2779
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.resize(true, 1, a); }";
2780
        let result = try resolveProgramStr(&mut a, program);
2781
        let err = try expectError(&result);
2782
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2783
            else throw testing::TestError::Failed;
2784
    }
2785
}
2786
2787
/// Test `.extend()` accepts a mutable source and rejects bad receivers, sources, and element types.
2788
@test unsafe fn testResolveSliceExtendRejected() throws (testing::TestError) {
2789
    {
2790
        let mut a = testResolver();
2791
        let program =
2792
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: *mut [i32], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2793
        let result = try resolveProgramStr(&mut a, program);
2794
        try expectNoErrors(&result);
2795
    }
2796
    {
2797
        let mut a = testResolver();
2798
        let program =
2799
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *[i32], src: *[i32], a: &Heap) { try! s.extend(src, a); }";
2800
        let result = try resolveProgramStr(&mut a, program);
2801
        try expectErrorKind(&result, resolver::ErrorKind::SliceNotMutable);
2802
    }
2803
    {
2804
        let mut a = testResolver();
2805
        let program =
2806
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record N { x: i32 } fn f(owned: *mut [N], src: *[N], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2807
        let result = try resolveProgramStr(&mut a, program);
2808
        try expectErrorKind(&result, resolver::ErrorKind::SliceElemNotCopy);
2809
    }
2810
    {
2811
        let mut a = testResolver();
2812
        let program =
2813
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: *[u8], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2814
        let result = try resolveProgramStr(&mut a, program);
2815
        let err = try expectError(&result);
2816
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2817
            else throw testing::TestError::Failed;
2818
    }
2819
    {
2820
        let mut a = testResolver();
2821
        let program =
2822
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: i32, a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2823
        let result = try resolveProgramStr(&mut a, program);
2824
        let err = try expectError(&result);
2825
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2826
            else throw testing::TestError::Failed;
2827
    }
2828
}
2829
2830
/// Test `.extend()` accepts a borrowed source of either mutability, and a sub-slice of a local
2831
/// array.
2832
@test unsafe fn testResolveSliceExtendBorrowedSource() throws (testing::TestError) {
2833
    for program in [
2834
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: &[i32], a: &Heap) { let mut s = owned; try! s.extend(src, a); }",
2835
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: &mut [i32], a: &Heap) { let mut s = owned; try! s.extend(src, a); }",
2836
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [u8], n: u32, a: &Heap) { let mut s = owned; let buf: [u8; 4] = [0; 4]; try! s.extend(&buf[..n], a); }",
2837
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record B { items: [i32; 4] } fn f(owned: *mut [i32], b: &B, a: &Heap) { let mut s = owned; try! s.extend(&b.items[1..3], a); }",
2838
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &mut *mut [i32], src: &[i32], a: &Heap) { try! items.extend(src, a); }",
2839
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} unsafe fn f(owned: *mut [i32], src: *unsafe [i32], a: &Heap) { let mut s = owned; try! s.extend(src, a); }",
2840
    ] {
2841
        let mut a = testResolver();
2842
        let result = try resolveProgramStr(&mut a, program);
2843
        try expectNoErrors(&result);
2844
    }
2845
}
2846
2847
/// Test `.extend()` still rejects a borrowed source of another element type, a non-`Copy` element,
2848
/// and a non-slice source.
2849
@test unsafe fn testResolveSliceExtendBorrowedRejected() throws (testing::TestError) {
2850
    {
2851
        let mut a = testResolver();
2852
        let program =
2853
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: &[u8], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2854
        let result = try resolveProgramStr(&mut a, program);
2855
        let err = try expectError(&result);
2856
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2857
            else throw testing::TestError::Failed;
2858
    }
2859
    {
2860
        let mut a = testResolver();
2861
        let program =
2862
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record N { x: i32 } fn f(owned: *mut [N], src: &[N], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2863
        let result = try resolveProgramStr(&mut a, program);
2864
        try expectErrorKind(&result, resolver::ErrorKind::SliceElemNotCopy);
2865
    }
2866
    {
2867
        let mut a = testResolver();
2868
        let program =
2869
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: &i32, a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2870
        let result = try resolveProgramStr(&mut a, program);
2871
        let err = try expectError(&result);
2872
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2873
            else throw testing::TestError::Failed;
2874
    }
2875
    {
2876
        let mut a = testResolver();
2877
        let program =
2878
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: [i32; 4], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2879
        let result = try resolveProgramStr(&mut a, program);
2880
        let err = try expectError(&result);
2881
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
2882
            else throw testing::TestError::Failed;
2883
    }
2884
    {
2885
        let mut a = testResolver();
2886
        let program =
2887
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], src: *unsafe [i32], a: &Heap) { let mut s = owned; try! s.extend(src, a); }";
2888
        let result = try resolveProgramStr(&mut a, program);
2889
        try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation);
2890
    }
2891
}
2892
2893
/// Test `.extend()` accepts a source that names the receiver, as `.append()` accepts an element
2894
/// read from it.
2895
@test unsafe fn testResolveSliceExtendSelfSource() throws (testing::TestError) {
2896
    {
2897
        let mut a = testResolver();
2898
        let program =
2899
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.extend(&s[..], a); }";
2900
        let result = try resolveProgramStr(&mut a, program);
2901
        try expectNoErrors(&result);
2902
    }
2903
    {
2904
        let mut a = testResolver();
2905
        let program =
2906
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(owned: *mut [i32], a: &Heap) { let mut s = owned; try! s.append(s[0], a); }";
2907
        let result = try resolveProgramStr(&mut a, program);
2908
        try expectNoErrors(&result);
2909
    }
2910
}
2911
2912
/// Test `.delete()` on immutable slice produces an error.
2913
@test unsafe fn testResolveSliceDeleteImmutable() throws (testing::TestError) {
2914
    let mut a = testResolver();
2915
    let program = "fn f(s: *[i32]) { s.delete(0); }";
2916
    let result = try resolveProgramStr(&mut a, program);
2917
    let err = try expectError(&result);
2918
    let case resolver::ErrorKind::SliceNotMutable = err.kind else throw testing::TestError::Failed;
2919
}
2920
2921
/// Test `.delete()` with wrong argument count produces an error.
2922
@test unsafe fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
2923
    // No arguments.
2924
    {
2925
        let mut a = testResolver();
2926
        let program = "fn f(owned: *mut [i32]) { let mut s = owned; s.delete(); }";
2927
        let result = try resolveProgramStr(&mut a, program);
2928
        let err = try expectError(&result);
2929
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2930
            else throw testing::TestError::Failed;
2931
        try testing::expect(m.expected == 1);
2932
        try testing::expect(m.actual == 0);
2933
    }
2934
    // Too many arguments.
2935
    {
2936
        let mut a = testResolver();
2937
        let program = "fn f(owned: *mut [i32]) { let mut s = owned; s.delete(0, 1); }";
2938
        let result = try resolveProgramStr(&mut a, program);
2939
        let err = try expectError(&result);
2940
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2941
            else throw testing::TestError::Failed;
2942
        try testing::expect(m.expected == 1);
2943
        try testing::expect(m.actual == 2);
2944
    }
2945
}
2946
2947
/// Test `.delete()` with correct arguments succeeds.
2948
@test unsafe fn testResolveSliceDeleteCorrect() throws (testing::TestError) {
2949
    let mut a = testResolver();
2950
    let program = "fn f(owned: *mut [i32]) { let mut s = owned; s.delete(0); }";
2951
    let result = try resolveProgramStr(&mut a, program);
2952
    try expectNoErrors(&result);
2953
}
2954
2955
/// Test `.delete()` with wrong argument type produces an error.
2956
@test unsafe fn testResolveSliceDeleteWrongArgType() throws (testing::TestError) {
2957
    let mut a = testResolver();
2958
    let program = "fn f(owned: *mut [i32]) { let mut s = owned; s.delete(true); }";
2959
    let result = try resolveProgramStr(&mut a, program);
2960
    let err = try expectError(&result);
2961
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2962
}
2963
2964
/// Test `.take()` accepts a mutable owned slice place and returns the slice value.
2965
@test unsafe fn testResolveSliceTakeAccepted() throws (testing::TestError) {
2966
    for program in [
2967
        "fn f() -> *mut [i32] { let mut s: *mut [i32] = &mut []; return s.take(); }",
2968
        "record N { x: i32 } fn f() -> *mut [N] { let mut s: *mut [N] = &mut []; return s.take(); }",
2969
        "record G { e: *mut [i32] } fn f(g: &mut G) -> *mut [i32] { return g.e.take(); }",
2970
        "record G { e: *mut [i32] } fn f(g: *mut G) -> *mut [i32] { return g.e.take(); }",
2971
        "fn f(s: *mut [i32]) -> *mut [i32] { return s.take(); }",
2972
    ] {
2973
        let mut a = testResolver();
2974
        let result = try resolveProgramStr(&mut a, program);
2975
        try expectNoErrors(&result);
2976
    }
2977
}
2978
2979
/// Test `.take()` with arguments produces an argument count error.
2980
@test unsafe fn testResolveSliceTakeArgCount() throws (testing::TestError) {
2981
    let mut a = testResolver();
2982
    let program = "fn f() -> *mut [i32] { let mut s: *mut [i32] = &mut []; return s.take(0); }";
2983
    let result = try resolveProgramStr(&mut a, program);
2984
    let err = try expectError(&result);
2985
    let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
2986
        else throw testing::TestError::Failed;
2987
    try testing::expect(m.expected == 0);
2988
    try testing::expect(m.actual == 1);
2989
}
2990
2991
/// Test `.take()` on an immutable place or an immutable slice type produces an error.
2992
@test unsafe fn testResolveSliceTakeImmutable() throws (testing::TestError) {
2993
    for program in [
2994
        "fn f(s: *[i32]) -> *mut [i32] { return s.take(); }",
2995
        "fn f(s: &[i32]) -> *mut [i32] { return s.take(); }",
2996
        "fn f() -> *mut [i32] { let mut s: *[i32] = &[]; return s.take(); }",
2997
        "fn f() -> *mut [i32] { let s: *mut [i32] = &mut []; return s.take(); }",
2998
    ] {
2999
        let mut a = testResolver();
3000
        let result = try resolveProgramStr(&mut a, program);
3001
        let err = try expectError(&result);
3002
        let case resolver::ErrorKind::SliceNotMutable = err.kind
3003
            else throw testing::TestError::Failed;
3004
    }
3005
    // A field behind an immutable reference.
3006
    let mut a = testResolver();
3007
    let program = "record G { e: *mut [i32] } fn f(g: &G) -> *mut [i32] { return g.e.take(); }";
3008
    let result = try resolveProgramStr(&mut a, program);
3009
    try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
3010
}
3011
3012
/// Test `.take()` on a borrowed slice reference produces an error, because the result is owned.
3013
@test unsafe fn testResolveSliceTakeBorrowed() throws (testing::TestError) {
3014
    let mut a = testResolver();
3015
    let program = "fn f(s: &mut [i32]) -> *mut [i32] { return s.take(); }";
3016
    let result = try resolveProgramStr(&mut a, program);
3017
    let err = try expectError(&result);
3018
    let case resolver::ErrorKind::SliceNotOwned = err.kind else throw testing::TestError::Failed;
3019
}
3020
3021
/// Test `.take()` on a non-slice receiver produces an error.
3022
@test unsafe fn testResolveSliceTakeNonSlice() throws (testing::TestError) {
3023
    let mut a = testResolver();
3024
    let program = "fn f(x: u32) -> *mut [i32] { return x.take(); }";
3025
    let result = try resolveProgramStr(&mut a, program);
3026
    try expectError(&result);
3027
}
3028
3029
/// Test that `append`, `reserve`, `resize`, `extend`, and `delete` accept a receiver
3030
/// place that can be assigned: a `*mut [T]` parameter, a `let mut` local, a field behind
3031
/// `&mut`, or a field behind a mutable owned pointer.
3032
@test unsafe fn testResolveSliceMutatorMutablePlace() throws (testing::TestError) {
3033
    for program in [
3034
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let mut s: *mut [i32] = &mut []; try! s.append(1, a); }",
3035
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &mut G, src: *[i32], a: &Heap) { try! g.e.append(1, a); }",
3036
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: *mut G, src: *[i32], a: &Heap) { try! g.e.append(1, a); }",
3037
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let mut s: *mut [i32] = &mut []; try! s.reserve(1, a); }",
3038
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &mut G, src: *[i32], a: &Heap) { try! g.e.reserve(1, a); }",
3039
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: *mut G, src: *[i32], a: &Heap) { try! g.e.reserve(1, a); }",
3040
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let mut s: *mut [i32] = &mut []; try! s.resize(1, 1, a); }",
3041
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &mut G, src: *[i32], a: &Heap) { try! g.e.resize(1, 1, a); }",
3042
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: *mut G, src: *[i32], a: &Heap) { try! g.e.resize(1, 1, a); }",
3043
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let mut s: *mut [i32] = &mut []; try! s.extend(src, a); }",
3044
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &mut G, src: *[i32], a: &Heap) { try! g.e.extend(src, a); }",
3045
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: *mut G, src: *[i32], a: &Heap) { try! g.e.extend(src, a); }",
3046
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *mut [i32], src: *[i32], a: &Heap) { try! s.append(1, a); }",
3047
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *mut [i32], src: *[i32], a: &Heap) { try! s.reserve(1, a); }",
3048
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *mut [i32], src: *[i32], a: &Heap) { try! s.resize(1, 1, a); }",
3049
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(s: *mut [i32], src: *[i32], a: &Heap) { try! s.extend(src, a); }",
3050
        "fn f(s: *mut [i32]) { s.delete(0); }",
3051
        "fn f() { let mut s: *mut [i32] = &mut []; s.delete(0); }",
3052
        "record G { e: *mut [i32] } fn f(g: &mut G) { g.e.delete(0); }",
3053
        "record G { e: *mut [i32] } fn f(g: *mut G) { g.e.delete(0); }",
3054
    ] {
3055
        let mut a = testResolver();
3056
        let result = try resolveProgramStr(&mut a, program);
3057
        try expectNoErrors(&result);
3058
    }
3059
}
3060
3061
/// Test that a `*mut [T]` parameter that moved away cannot change, because another binding
3062
/// holds the slice now.
3063
@test unsafe fn testResolveSliceMutatorMovedParam() throws (testing::TestError) {
3064
    for program in [
3065
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} fn f(s: *mut [i32], a: &Heap) throws (AllocError) { let t = s; try s.append(1, a); }",
3066
        "fn f(s: *mut [i32]) { let t = s; s.delete(0); }",
3067
        "fn f(s: *mut [i32]) -> *mut [i32] { let t = s; return s.take(); }",
3068
        "fn g(s: *mut [i32]) {} fn f(s: *mut [i32]) { g(s); s.delete(0); }",
3069
    ] {
3070
        let mut a = testResolver();
3071
        let result = try resolveProgramStr(&mut a, program);
3072
        try expectErrorKind(&result, resolver::ErrorKind::AffineUseAfterMove("s"));
3073
    }
3074
}
3075
3076
/// Test that `append`, `reserve`, `resize`, `extend`, and `delete` reject a receiver
3077
/// place that cannot be assigned. An immutable `let` binding
3078
/// produces SliceNotMutable, and a field behind `&` produces ImmutablePointer.
3079
@test unsafe fn testResolveSliceMutatorImmutablePlace() throws (testing::TestError) {
3080
    for program in [
3081
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let s: *mut [i32] = &mut []; try! s.append(1, a); }",
3082
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let s: *mut [i32] = &mut []; try! s.reserve(1, a); }",
3083
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let s: *mut [i32] = &mut []; try! s.resize(1, 1, a); }",
3084
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(src: *[i32], a: &Heap) { let s: *mut [i32] = &mut []; try! s.extend(src, a); }",
3085
        "fn f() { let s: *mut [i32] = &mut []; s.delete(0); }",
3086
    ] {
3087
        let mut a = testResolver();
3088
        let result = try resolveProgramStr(&mut a, program);
3089
        let err = try expectError(&result);
3090
        let case resolver::ErrorKind::SliceNotMutable = err.kind
3091
            else throw testing::TestError::Failed;
3092
    }
3093
    // A field behind an immutable reference.
3094
    for program in [
3095
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &G, src: *[i32], a: &Heap) { try! g.e.append(1, a); }",
3096
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &G, src: *[i32], a: &Heap) { try! g.e.reserve(1, a); }",
3097
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &G, src: *[i32], a: &Heap) { try! g.e.resize(1, 1, a); }",
3098
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} record G { e: *mut [i32] } fn f(g: &G, src: *[i32], a: &Heap) { try! g.e.extend(src, a); }",
3099
        "record G { e: *mut [i32] } fn f(g: &G) { g.e.delete(0); }",
3100
    ] {
3101
        let mut a = testResolver();
3102
        let result = try resolveProgramStr(&mut a, program);
3103
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
3104
    }
3105
}
3106
3107
/// Test that the six slice mutators accept a receiver that is a mutable reference to a
3108
/// slice pointer, as `(*items)` is.
3109
@test unsafe fn testResolveSliceMutatorMutableRefPlace() throws (testing::TestError) {
3110
    for program in [
3111
        "fn f(items: &mut *mut [i32]) -> *mut [i32] { return items.take(); }",
3112
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &mut *mut [i32], a: &Heap) { try! items.append(1, a); }",
3113
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &mut *mut [i32], a: &Heap) { try! items.reserve(1, a); }",
3114
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &mut *mut [i32], a: &Heap) { try! items.resize(1, 1, a); }",
3115
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &mut *mut [i32], src: *[i32], a: &Heap) { try! items.extend(src, a); }",
3116
        "fn f(items: &mut *mut [i32]) { items.delete(0); }",
3117
    ] {
3118
        let mut a = testResolver();
3119
        let result = try resolveProgramStr(&mut a, program);
3120
        try expectNoErrors(&result);
3121
    }
3122
}
3123
3124
/// Test that the six slice mutators reject a receiver that is an immutable reference to a
3125
/// slice pointer, whether it is a parameter or a reference local. The slice header is
3126
/// behind the immutable reference.
3127
@test unsafe fn testResolveSliceMutatorImmutableRefPlace() throws (testing::TestError) {
3128
    for program in [
3129
        "fn f(items: &*mut [i32]) -> *mut [i32] { return items.take(); }",
3130
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &*mut [i32], a: &Heap) { try! items.append(1, a); }",
3131
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &*mut [i32], a: &Heap) { try! items.reserve(1, a); }",
3132
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &*mut [i32], a: &Heap) { try! items.resize(1, 1, a); }",
3133
        "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(items: &*mut [i32], src: *[i32], a: &Heap) { try! items.extend(src, a); }",
3134
        "fn f(items: &*mut [i32]) { items.delete(0); }",
3135
        "fn f() { let mut s: *mut [i32] = &mut []; let items: &*mut [i32] = &s; items.delete(0); }",
3136
    ] {
3137
        let mut a = testResolver();
3138
        let result = try resolveProgramStr(&mut a, program);
3139
        let err = try expectError(&result);
3140
        let case resolver::ErrorKind::ImmutablePointer = err.kind
3141
            else throw testing::TestError::Failed;
3142
    }
3143
}
3144
3145
/// Test `match &opt` produces immutable pointer bindings.
3146
@test unsafe fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
3147
    let mut a = testResolver();
3148
    let program =
3149
        "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
3150
    let result = try resolveProgramStr(&mut a, program);
3151
    try expectNoErrors(&result);
3152
3153
    let fnBlock = try getFnBody(&a, result.root, "f");
3154
    let matchNode = fnBlock.statements[1];
3155
    let case ast::NodeValue::Match(sw) = matchNode.value else throw testing::TestError::Failed;
3156
    let caseNode = sw.prongs[0];
3157
3158
    let scope = resolver::scopeFor(&a, caseNode) else throw testing::TestError::Failed;
3159
    let payloadSym = resolver::findSymbolInScope(&a, scope, "x")
3160
        else throw testing::TestError::Failed;
3161
    let case resolver::SymbolData::Value { type: payloadValType, .. } = a.symbols[*payloadSym].data
3162
        else throw testing::TestError::Failed;
3163
    let case resolver::Type::Pointer { class: types::PointerClass::Ref, target, mutable } =
3164
        payloadValType else throw testing::TestError::Failed;
3165
    try testing::expect(not mutable);
3166
    try testing::expect(*target == resolver::Type::I32);
3167
}
3168
3169
/// Test `match &mut opt` produces mutable pointer bindings.
3170
@test unsafe fn testResolveMatchMutRefUnionBinding() throws (testing::TestError) {
3171
    let mut a = testResolver();
3172
    let program =
3173
        "union Opt { Some(i32), None } fn f() { let mut opt = Opt::Some(42); match &mut opt { case Opt::Some(x) => { *x; } else => {} } }";
3174
    let result = try resolveProgramStr(&mut a, program);
3175
    try expectNoErrors(&result);
3176
3177
    let fnBlock = try getFnBody(&a, result.root, "f");
3178
    let matchNode = fnBlock.statements[1];
3179
    let case ast::NodeValue::Match(sw) = matchNode.value else throw testing::TestError::Failed;
3180
    let caseNode = sw.prongs[0];
3181
3182
    let scope = resolver::scopeFor(&a, caseNode) else throw testing::TestError::Failed;
3183
    let payloadSym = resolver::findSymbolInScope(&a, scope, "x")
3184
        else throw testing::TestError::Failed;
3185
    let case resolver::SymbolData::Value { type: payloadValType, .. } = a.symbols[*payloadSym].data
3186
        else throw testing::TestError::Failed;
3187
    let case resolver::Type::Pointer { class: types::PointerClass::Ref, target, mutable } =
3188
        payloadValType else throw testing::TestError::Failed;
3189
    try testing::expect(mutable);
3190
    try testing::expect(*target == resolver::Type::I32);
3191
}
3192
3193
/// Non-constant integer widening must use an explicit cast.
3194
@test unsafe fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
3195
    {
3196
        let mut a = testResolver();
3197
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x;");
3198
        let err = try expectError(&result);
3199
        try expectTypeMismatch(err, resolver::Type::U32, resolver::Type::U8);
3200
    }
3201
    {
3202
        let mut a = testResolver();
3203
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u16 = x;");
3204
        let err = try expectError(&result);
3205
        try expectTypeMismatch(err, resolver::Type::U16, resolver::Type::U8);
3206
    }
3207
    {
3208
        let mut a = testResolver();
3209
        let result = try resolveBlockStr(&mut a, "let x: u16 = 1; let y: u32 = x;");
3210
        let err = try expectError(&result);
3211
        try expectTypeMismatch(err, resolver::Type::U32, resolver::Type::U16);
3212
    }
3213
    {
3214
        let mut a = testResolver();
3215
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x;");
3216
        let err = try expectError(&result);
3217
        try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::I8);
3218
    }
3219
    {
3220
        let mut a = testResolver();
3221
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x as u32;");
3222
        try expectNoErrors(&result);
3223
    }
3224
    {
3225
        let mut a = testResolver();
3226
        let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x as i32;");
3227
        try expectNoErrors(&result);
3228
    }
3229
}
3230
3231
/// Mixed-width integer binary ops require an explicit cast.
3232
@test unsafe fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
3233
    {
3234
        let mut a = testResolver();
3235
        let result = try resolveBlockStr(
3236
            &mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x | y;"
3237
        );
3238
        let err = try expectError(&result);
3239
        try expectTypeMismatch(err, resolver::Type::U8, resolver::Type::U32);
3240
    }
3241
    {
3242
        let mut a = testResolver();
3243
        let result = try resolveBlockStr(
3244
            &mut a, "let x: u8 = 1; let y: u32 = 0xFF; let z: u32 = x & y;"
3245
        );
3246
        let err = try expectError(&result);
3247
        try expectTypeMismatch(err, resolver::Type::U8, resolver::Type::U32);
3248
    }
3249
    {
3250
        let mut a = testResolver();
3251
        let result = try resolveBlockStr(
3252
            &mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = x + y;"
3253
        );
3254
        let err = try expectError(&result);
3255
        try expectTypeMismatch(err, resolver::Type::U8, resolver::Type::U32);
3256
    }
3257
    {
3258
        let mut a = testResolver();
3259
        let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u8 = x << 2;");
3260
        try expectNoErrors(&result);
3261
    }
3262
    {
3263
        let mut a = testResolver();
3264
        let result = try resolveBlockStr(
3265
            &mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) | y;"
3266
        );
3267
        try expectNoErrors(&result);
3268
    }
3269
    {
3270
        let mut a = testResolver();
3271
        let result = try resolveBlockStr(
3272
            &mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) + y;"
3273
        );
3274
        try expectNoErrors(&result);
3275
    }
3276
}
3277
3278
/// A mutable slice pointer should be assignable to an immutable slice pointer.
3279
@test unsafe fn testResolveMutSliceAssignableToImmutSlice() throws (testing::TestError) {
3280
    let mut a = testResolver();
3281
    let result = try resolveBlockStr(
3282
        &mut a,
3283
        "static arr: [i32; 3] = [1, 2, 3]; unsafe { let p: *mut [i32] = &mut arr[..]; let q: *[i32] = p; }"
3284
    );
3285
    try expectNoErrors(&result);
3286
}
3287
3288
/// Comprehensive tests for `as` cast expressions.
3289
@test unsafe fn testResolveAsCasts() throws (testing::TestError) {
3290
    {
3291
        // Pointer to numeric.
3292
        let mut a = testResolver();
3293
        let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
3294
        try expectNoErrors(&result);
3295
    }
3296
    {
3297
        // Function pointer to numeric.
3298
        let mut a = testResolver();
3299
        let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
3300
        try expectNoErrors(&result);
3301
    }
3302
    {
3303
        // *u8 to *i32 (u8 to i32 is valid).
3304
        let mut a = testResolver();
3305
        let result = try resolveProgramStr(
3306
            &mut a, "unsafe fn run() { let p: *u8 = undefined; p as *i32; }"
3307
        );
3308
        try expectNoErrors(&result);
3309
    }
3310
    {
3311
        // **u8 to **i32 (*u8 to *i32 is valid).
3312
        let mut a = testResolver();
3313
        let result = try resolveProgramStr(
3314
            &mut a, "unsafe fn run() { let p: **u8 = undefined; p as **i32; }"
3315
        );
3316
        try expectNoErrors(&result);
3317
    }
3318
    {
3319
        // *[i32] to *[opaque].
3320
        let mut a = testResolver();
3321
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *[opaque]; }");
3322
        try expectNoErrors(&result);
3323
    }
3324
    {
3325
        // *[opaque] to *[i32].
3326
        let mut a = testResolver();
3327
        let result = try resolveProgramStr(
3328
            &mut a, "unsafe fn run() { let s: *[opaque] = undefined; s as *[i32]; }"
3329
        );
3330
        try expectNoErrors(&result);
3331
    }
3332
    {
3333
        // *[i32] to *[u8].
3334
        let mut a = testResolver();
3335
        let result = try resolveProgramStr(
3336
            &mut a, "unsafe fn run() { let s: *[i32] = undefined; s as *[u8]; }"
3337
        );
3338
        try expectNoErrors(&result);
3339
    }
3340
    {
3341
        // *[record] to *[u8].
3342
        let mut a = testResolver();
3343
        let result = try resolveProgramStr(
3344
            &mut a, "record R { x: i32 } unsafe fn f(s: *[R]) { s as *[u8]; }"
3345
        );
3346
        try expectNoErrors(&result);
3347
    }
3348
    {
3349
        // *[u8] to *[i32].
3350
        let mut a = testResolver();
3351
        let result = try resolveProgramStr(
3352
            &mut a, "unsafe fn run() { let s: *[u8] = undefined; s as *[i32]; }"
3353
        );
3354
        try expectNoErrors(&result);
3355
    }
3356
    {
3357
        // *[*u8] to *[*i32]
3358
        let mut a = testResolver();
3359
        let result = try resolveProgramStr(
3360
            &mut a, "unsafe fn run() { let s: *[*u8] = undefined; s as *[*i32]; }"
3361
        );
3362
        try expectNoErrors(&result);
3363
    }
3364
    {
3365
        // Identity cast: *mut [i32] to *mut [i32].
3366
        let mut a = testResolver();
3367
        let result = try resolveProgramStr(&mut a, "fn run(s: *mut [i32]) { s as *mut [i32]; }");
3368
        try expectNoErrors(&result);
3369
    }
3370
    {
3371
        // Identity cast: *i32 to *i32.
3372
        let mut a = testResolver();
3373
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *i32; }");
3374
        try expectNoErrors(&result);
3375
    }
3376
    {
3377
        // Identity cast: i32 to i32.
3378
        let mut a = testResolver();
3379
        let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
3380
        try expectNoErrors(&result);
3381
    }
3382
}
3383
3384
/// Tests for invalid `as` casts that should be rejected.
3385
@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
3386
    {
3387
        // Pointer to slice is invalid.
3388
        let mut a = testResolver();
3389
        let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *[i32]; }");
3390
        let err = try expectError(&result);
3391
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3392
            else throw testing::TestError::Failed;
3393
    }
3394
    {
3395
        // Slice to pointer is invalid.
3396
        let mut a = testResolver();
3397
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *i32; }");
3398
        let err = try expectError(&result);
3399
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3400
            else throw testing::TestError::Failed;
3401
    }
3402
    {
3403
        // *T to *i32 is invalid.
3404
        let mut a = testResolver();
3405
        let result = try resolveProgramStr(
3406
            &mut a, "record R { x: i32 } fn f(p: *R) { p as *i32; }"
3407
        );
3408
        let err = try expectError(&result);
3409
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3410
            else throw testing::TestError::Failed;
3411
    }
3412
    {
3413
        // *[T] to *[i32] is invalid.
3414
        let mut a = testResolver();
3415
        let result = try resolveProgramStr(
3416
            &mut a, "record R { x: i32 } fn f(s: *[R]) { s as *[i32]; }"
3417
        );
3418
        let err = try expectError(&result);
3419
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3420
            else throw testing::TestError::Failed;
3421
    }
3422
    {
3423
        // Slice to numeric is invalid.
3424
        let mut a = testResolver();
3425
        let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
3426
        let err = try expectError(&result);
3427
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3428
            else throw testing::TestError::Failed;
3429
    }
3430
    {
3431
        // *record to *u8 is invalid.
3432
        let mut a = testResolver();
3433
        let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
3434
        let err = try expectError(&result);
3435
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
3436
            else throw testing::TestError::Failed;
3437
    }
3438
}
3439
3440
/// Test that catch binding is available in catch block scope.
3441
@test unsafe fn testResolveTryCatchBinding() throws (testing::TestError) {
3442
    {
3443
        let mut a = testResolver();
3444
        let program =
3445
            "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { return 0; }; }";
3446
        let result = try resolveProgramStr(&mut a, program);
3447
        try expectNoErrors(&result);
3448
    }
3449
    {
3450
        let mut a = testResolver();
3451
        let program =
3452
            "union Error { A, B } fn fallible() -> u32 throws (Error) { throw Error::A; } fn caller() -> u32 { return try fallible() catch e { if e == Error::A { return 1; } else { return 2; } }; }";
3453
        let result = try resolveProgramStr(&mut a, program);
3454
        try expectNoErrors(&result);
3455
    }
3456
    {
3457
        let mut a = testResolver();
3458
        let program =
3459
            "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; } fn caller() -> u32 { return try fallible() catch err { if err == Error::Fail { return 1; } return 0; }; }";
3460
        let result = try resolveProgramStr(&mut a, program);
3461
        try expectNoErrors(&result);
3462
    }
3463
    {
3464
        let mut a = testResolver();
3465
        let program =
3466
            "union Error { Fail(u32) } fn fallible() -> u32 throws (Error) { throw Error::Fail(42); } fn caller() -> u32 { return try fallible() catch err { match err { case Error::Fail(x) => return x, } }; }";
3467
        let result = try resolveProgramStr(&mut a, program);
3468
        try expectNoErrors(&result);
3469
    }
3470
}
3471
3472
/// Test that duplicate union variant patterns are detected.
3473
@test unsafe fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
3474
    {
3475
        let mut a = testResolver();
3476
        let program =
3477
            "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::A => {}, else => {} } }";
3478
        let result = try resolveProgramStr(&mut a, program);
3479
        try expectErrorKind(&result, resolver::ErrorKind::DuplicateMatchPattern);
3480
    }
3481
    {
3482
        // No duplicate: distinct variants are fine.
3483
        let mut a = testResolver();
3484
        let program =
3485
            "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {} } }";
3486
        let result = try resolveProgramStr(&mut a, program);
3487
        try expectNoErrors(&result);
3488
    }
3489
}
3490
3491
/// Test that duplicate bool patterns are detected.
3492
@test unsafe fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
3493
    {
3494
        let mut a = testResolver();
3495
        let program = "fn f(x: bool) { match x { case true => {}, case true => {}, else => {} } }";
3496
        let result = try resolveProgramStr(&mut a, program);
3497
        try expectErrorKind(&result, resolver::ErrorKind::DuplicateMatchPattern);
3498
    }
3499
    {
3500
        let mut a = testResolver();
3501
        let program =
3502
            "fn f(x: bool) { match x { case false => {}, case false => {}, else => {} } }";
3503
        let result = try resolveProgramStr(&mut a, program);
3504
        try expectErrorKind(&result, resolver::ErrorKind::DuplicateMatchPattern);
3505
    }
3506
}
3507
3508
/// Test that duplicate nil patterns in optional match are detected.
3509
@test unsafe fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
3510
    {
3511
        let mut a = testResolver();
3512
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, case nil => {} } }";
3513
        let result = try resolveProgramStr(&mut a, program);
3514
        try expectErrorKind(&result, resolver::ErrorKind::DuplicateMatchPattern);
3515
    }
3516
    {
3517
        // Duplicate value binding.
3518
        let mut a = testResolver();
3519
        let program = "fn f(opt: ?i32) { match opt { v => {}, w => {}, case nil => {} } }";
3520
        let result = try resolveProgramStr(&mut a, program);
3521
        try expectErrorKind(&result, resolver::ErrorKind::DuplicateMatchPattern);
3522
    }
3523
}
3524
3525
/// Test that guarded match arms are not considered duplicates.
3526
@test unsafe fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
3527
    {
3528
        // Guarded union variant followed by same variant is fine.
3529
        let mut a = testResolver();
3530
        let program =
3531
            "union U { A, B } fn f(u: U) { match u { case U::A if true => {}, case U::A => {}, case U::B => {} } }";
3532
        let result = try resolveProgramStr(&mut a, program);
3533
        try expectNoErrors(&result);
3534
    }
3535
    {
3536
        // Guarded bool pattern followed by same bool is fine.
3537
        let mut a = testResolver();
3538
        let program =
3539
            "fn f(x: bool) { match x { case true if true => {}, case true => {}, case false => {} } }";
3540
        let result = try resolveProgramStr(&mut a, program);
3541
        try expectNoErrors(&result);
3542
    }
3543
    {
3544
        // Guarded nil pattern followed by nil is fine.
3545
        let mut a = testResolver();
3546
        let program =
3547
            "fn f(opt: ?i32) { match opt { case nil if true => {}, case nil => {}, v => {} } }";
3548
        let result = try resolveProgramStr(&mut a, program);
3549
        try expectNoErrors(&result);
3550
    }
3551
    {
3552
        // Guarded value binding followed by another binding is fine.
3553
        let mut a = testResolver();
3554
        let program = "fn f(opt: ?i32) { match opt { v if true => {}, w => {}, case nil => {} } }";
3555
        let result = try resolveProgramStr(&mut a, program);
3556
        try expectNoErrors(&result);
3557
    }
3558
}
3559
3560
/// A last prong whose patterns test nested values does not make a match exhaustive. The
3561
/// match needs an arm that covers the rest of the subject.
3562
@test unsafe fn testResolveMatchRefiningLastProngNotExhaustive() throws (testing::TestError) {
3563
    try expectProgramError(
3564
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: Ty) { match t { case Ty::Other => {}, case Ty::Ptr { class: Class::Ref }, Ty::Pos(_) => {} } }",
3565
        resolver::ErrorKind::UnionMatchNonExhaustive("Ptr")
3566
    );
3567
    try expectProgramError(
3568
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: Ty) { match t { case Ty::Other, Ty::Ptr { class: _ } => {}, case Ty::Pos(Class::Ref) => {} } }",
3569
        resolver::ErrorKind::UnionMatchNonExhaustive("Pos")
3570
    );
3571
    try expectProgramError(
3572
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: &Ty) { match t { case Ty::Other, Ty::Pos(_) => {}, case Ty::Ptr { class: Class::Ref } => {} } }",
3573
        resolver::ErrorKind::UnionMatchNonExhaustive("Ptr")
3574
    );
3575
    try expectProgramError(
3576
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: ?Ty) { match t { case nil => {}, case Ty::Other, Ty::Pos(_) => {}, case Ty::Ptr { class: Class::Ref } => {} } }",
3577
        resolver::ErrorKind::UnionMatchNonExhaustive("Ptr")
3578
    );
3579
    try expectProgramError(
3580
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: ?P) { match t { case nil => {}, case P { a: 1, b } => {} } }",
3581
        resolver::ErrorKind::OptionalMatchMissingValue
3582
    );
3583
    try expectProgramError(
3584
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: P) { match t { case P { a: 1, b } => {} } }",
3585
        resolver::ErrorKind::MatchNonExhaustive
3586
    );
3587
    try expectProgramError(
3588
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: [u32; 2]) { match t { case [1, _] => {}, case [_, 2] => {} } }",
3589
        resolver::ErrorKind::MatchNonExhaustive
3590
    );
3591
    try expectProgramError(
3592
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: u32) { match t { case 1 => {}, case 2 => {} } }",
3593
        resolver::ErrorKind::MatchNonExhaustive
3594
    );
3595
    try expectProgramError(
3596
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: bool, u: bool) { match t { case true => {}, case false if u => {} } }",
3597
        resolver::ErrorKind::BoolMatchMissing(false)
3598
    );
3599
}
3600
3601
/// A prong with a nested test after a prong that covers its variant is accepted, whether it is
3602
/// the last prong or not. The match is exhaustive through the earlier prong.
3603
@test unsafe fn testResolveMatchRefiningProngAfterCoverOk() throws (testing::TestError) {
3604
    try expectProgramOk(
3605
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: Ty) { match t { case Ty::Ptr { class: _ }, Ty::Pos(_) => {}, case Ty::Other, Ty::Ptr { class: Class::Ref } => {} } }"
3606
    );
3607
    try expectProgramOk(
3608
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: Ty) { match t { case Ty::Ptr { class: _ }, Ty::Pos(_) => {}, case Ty::Other => {}, case Ty::Ptr { class: Class::Ref } => {} } }"
3609
    );
3610
    try expectProgramOk(
3611
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: ?Ty) { match t { case nil => {}, case Ty::Ptr { class: _ }, Ty::Pos(_), Ty::Other => {}, case Ty::Ptr { class: Class::Owned } => {} } }"
3612
    );
3613
    try expectProgramOk(
3614
        "union Class: Copy { Owned, Ref } union Ty: Copy { Ptr { class: Class }, Pos(Class), Other } record P: Copy { a: u32, b: u32 } fn f(t: Ty) { match t { case Ty::Ptr { class: Class::Ref } => {}, case Ty::Ptr { class: _ }, Ty::Pos(_), Ty::Other => {} } }"
3615
    );
3616
}
3617
3618
/// Test that unreachable else is detected when all union variants are covered.
3619
@test unsafe fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
3620
    {
3621
        let mut a = testResolver();
3622
        let program =
3623
            "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {}, else => {} } }";
3624
        let result = try resolveProgramStr(&mut a, program);
3625
        try expectErrorKind(&result, resolver::ErrorKind::UnreachableElse);
3626
    }
3627
    {
3628
        // Partial coverage with else is fine.
3629
        let mut a = testResolver();
3630
        let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }";
3631
        let result = try resolveProgramStr(&mut a, program);
3632
        try expectNoErrors(&result);
3633
    }
3634
}
3635
3636
/// Test that unreachable else is detected when both bool cases are covered.
3637
@test unsafe fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
3638
    {
3639
        let mut a = testResolver();
3640
        let program = "fn f(x: bool) { match x { case true => {}, case false => {}, else => {} } }";
3641
        let result = try resolveProgramStr(&mut a, program);
3642
        try expectErrorKind(&result, resolver::ErrorKind::UnreachableElse);
3643
    }
3644
    {
3645
        // Only one case with else is fine.
3646
        let mut a = testResolver();
3647
        let program = "fn f(x: bool) { match x { case true => {}, else => {} } }";
3648
        let result = try resolveProgramStr(&mut a, program);
3649
        try expectNoErrors(&result);
3650
    }
3651
}
3652
3653
/// Test that unreachable else is detected when both optional cases are covered.
3654
@test unsafe fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
3655
    {
3656
        let mut a = testResolver();
3657
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {}, else => {} } }";
3658
        let result = try resolveProgramStr(&mut a, program);
3659
        try expectErrorKind(&result, resolver::ErrorKind::UnreachableElse);
3660
    }
3661
    {
3662
        // Only value binding with else is fine.
3663
        let mut a = testResolver();
3664
        let program = "fn f(opt: ?i32) { match opt { v => {}, else => {} } }";
3665
        let result = try resolveProgramStr(&mut a, program);
3666
        try expectNoErrors(&result);
3667
    }
3668
}
3669
3670
/// Test that a prong after an unguarded catch-all is rejected.
3671
@test unsafe fn testResolveMatchProngAfterCatchAll() throws (testing::TestError) {
3672
    for program in [
3673
        // Integers.
3674
        "fn f(x: u32) { match x { else => {}, case 2 => {} } }",
3675
        "fn f(x: u32) { match x { case _ => {}, case 2 => {} } }",
3676
        "fn f(x: u32) { match x { case 1, _ => {}, case 2 => {} } }",
3677
        "fn f(x: u32) { match x { v => {}, case 2 => {} } }",
3678
        "fn f(x: u32) { match x { else => {}, case 2 if true => {} } }",
3679
        "fn f(x: u32) { match x { else => {}, v if v > 1 => {} } }",
3680
        "fn f(x: [u32; 2]) { match x { case [a, b] => {}, case [1, 2] => {} } }",
3681
        // Unions.
3682
        "union U { A, B } fn f(u: U) { match u { else => {}, case U::A => {} } }",
3683
        "union U { A, B } fn f(u: U) { match u { else => {}, case U::A => {}, case U::B => {} } }",
3684
        "union U { A, B } fn f(u: U) { match u { v => {}, case U::A => {} } }",
3685
        // Optionals.
3686
        "fn f(opt: ?i32) { match opt { else => {}, case nil => {} } }",
3687
        "fn f(opt: ?i32) { match opt { case _ => {}, v => {} } }",
3688
        "fn f(opt: ?i32) { match opt { case _ => {}, case nil if true => {} } }",
3689
        // Booleans.
3690
        "fn f(x: bool) { match x { else => {}, case true => {} } }",
3691
        // A second catch-all.
3692
        "fn f(x: u32) { match x { else => {}, case _ => {} } }",
3693
        "fn f(x: u32) { match x { case _ => {}, else => {} } }",
3694
        "union U { A, B } fn f(u: U) { match u { v => {}, else => {} } }",
3695
        "fn f(opt: ?i32) { match opt { else => {}, case _ => {} } }",
3696
    ] {
3697
        let mut a = testResolver();
3698
        let result = try resolveProgramStr(&mut a, program);
3699
        try expectErrorKind(&result, resolver::ErrorKind::CatchAllMustBeLast);
3700
    }
3701
}
3702
3703
/// Test that a prong with several alternatives cannot bind names.
3704
@test unsafe fn testResolveMatchAlternativeBinding() throws (testing::TestError) {
3705
    for program in [
3706
        // Record field shorthand and labeled fields.
3707
        "union U { A { x: u32 }, B { y: u32 } } fn f(u: U) { match u { case U::A { x }, U::B { y: _ } => {}, case _ => {} } }",
3708
        "union U { A { x: u32 }, B { y: u32 } } fn f(u: U) { match u { case U::A { x: _ }, U::B { y: v } => {}, case _ => {} } }",
3709
        // Positional payloads.
3710
        "union U { A(u32), B(u32), C } fn f(u: U) { match u { case U::A(x), U::C => {}, case _ => {} } }",
3711
        "union U { A(u32), B(u32), C } fn f(u: U) { match u { case U::C, U::B(x) => {}, case _ => {} } }",
3712
        "union U { A(u32), B(u32), C } fn f(u: U) { match u { case U::A(x), U::B(x) => {}, case _ => {} } }",
3713
        // Nested patterns.
3714
        "union I { P(u32), Q } union U { A { i: I }, B } fn f(u: U) { match u { case U::A { i: I::P(x) }, U::B => {}, case _ => {} } }",
3715
        "union I { P(u32), Q } union U { A { i: I }, B } fn f(u: U) { match u { case U::B, U::A { i: I::P(x) } => {}, case _ => {} } }",
3716
        // With a guard.
3717
        "union U { A(u32), B, C } fn f(u: U) { match u { case U::A(x), U::B if true => {}, case _ => {} } }",
3718
        // Records and arrays.
3719
        "record R { a: u32, b: u32 } fn f(r: R) { match r { case R { a: 1, b }, R { a: 2, b: _ } => {}, case _ => {} } }",
3720
        "fn f(a: [u32; 2]) { match a { case [1, x], [2, _] => {}, case _ => {} } }",
3721
        // Optionals.
3722
        "union U { A(u32), B } fn f(u: ?U) { match u { case U::A(x), nil => {}, case _ => {} } }",
3723
    ] {
3724
        let mut a = testResolver();
3725
        let result = try resolveProgramStr(&mut a, program);
3726
        try expectErrorKind(&result, resolver::ErrorKind::AlternativeBinding);
3727
    }
3728
}
3729
3730
/// Test that a single alternative may bind names and that several alternatives
3731
/// may test nested patterns and use wildcards.
3732
@test unsafe fn testResolveMatchAlternativeNoBinding() throws (testing::TestError) {
3733
    for program in [
3734
        "union U { A(u32), B(u32), C } fn f(u: U) { match u { case U::A(x) => {}, case U::B(_), U::C => {} } }",
3735
        "union U { A { x: u32 }, B } fn f(u: U) { match u { case U::A { x } => {}, case U::B => {} } }",
3736
        "union U { A { x: u32 }, B } fn f(u: U) { match u { case U::A { x: 1 }, U::A { x: _ } => {}, case U::B => {} } }",
3737
        "union U { A { x: u32 }, B } fn f(u: U) { match u { case U::A { x: 1 }, U::A { x: 2 } if true => {}, else => {} } }",
3738
        "union U { A { x: u32 }, B } fn f(u: U) { match u { case U::A { .. }, U::B => {} } }",
3739
        "union U { A(u32), B } fn f(u: ?U) { match u { case U::A(_), nil => {}, else => {} } }",
3740
        "fn f(a: [u32; 2]) { match a { case [1, _], [2, _] => {}, case [x, y] => {} } }",
3741
        "fn f(x: u32) { match x { case 1, 2 => {}, else => {} } }",
3742
        "fn f(x: u32) { match x { case 1, 2 if true => {}, v => {} } }",
3743
    ] {
3744
        let mut a = testResolver();
3745
        let result = try resolveProgramStr(&mut a, program);
3746
        try expectNoErrors(&result);
3747
    }
3748
}
3749
3750
/// Test that guarded catch-alls may be followed by further prongs, and that
3751
/// a catch-all in last position is accepted.
3752
@test unsafe fn testResolveMatchCatchAllPlacement() throws (testing::TestError) {
3753
    for program in [
3754
        "fn f(x: u32) { match x { case _ if x > 0 => {}, case 2 => {}, else => {} } }",
3755
        "fn f(x: u32) { match x { v if v > 0 => {}, case 2 => {}, else => {} } }",
3756
        "fn f(x: u32) { match x { case 2 => {}, else => {} } }",
3757
        "fn f(x: u32) { match x { case 2 => {}, case _ => {} } }",
3758
        "fn f(x: u32) { match x { case 2 => {}, v => {} } }",
3759
        "union U { A, B } fn f(u: U) { match u { v if true => {}, case U::A => {}, case U::B => {} } }",
3760
        "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }",
3761
        "union U { A, B } fn f(u: U) { match u { case U::A => {}, case _ => {} } }",
3762
        "union U { A, B } fn f(u: U) { match u { case _ if true => {}, case U::A => {}, case _ => {} } }",
3763
        "fn f(opt: ?i32) { match opt { case _ if true => {}, v => {}, case nil => {} } }",
3764
        "fn f(opt: ?i32) { match opt { case nil => {}, else => {} } }",
3765
        "fn f(x: bool) { match x { case true => {}, else => {} } }",
3766
    ] {
3767
        let mut a = testResolver();
3768
        let result = try resolveProgramStr(&mut a, program);
3769
        try expectNoErrors(&result);
3770
    }
3771
}
3772
3773
// Module order tests //////////////////////////////////////////////////////////
3774
3775
/// A record may embed a record from a sibling module declared later, even when
3776
/// that module's field types come from its own imports.
3777
@test unsafe fn testResolveRecordFieldFromLaterModule() throws (testing::TestError) {
3778
    let mut a = testResolver();
3779
    let rootId = try registerModule(
3780
        &mut super::MODULE_GRAPH,
3781
        nil,
3782
        "root",
3783
        "export mod limits; export mod state; export mod timers;"
3784
    );
3785
    try registerModule(&mut super::MODULE_GRAPH, rootId, "limits", "export constant MAX: u32 = 4;");
3786
    try registerModule(
3787
        &mut super::MODULE_GRAPH,
3788
        rootId,
3789
        "state",
3790
        "use super::timers; export record Shared { store: timers::Store }"
3791
    );
3792
    try registerModule(
3793
        &mut super::MODULE_GRAPH,
3794
        rootId,
3795
        "timers",
3796
        "use super::limits; export record Store { slots: [u32; limits::MAX] }"
3797
    );
3798
    let result = try resolveModuleTree(&mut a, rootId);
3799
    try expectNoErrors(&result);
3800
}
3801
3802
/// Errors found while resolving a record body on demand in another module are
3803
/// reported against that module, and later errors against the module being resolved.
3804
@test unsafe fn testResolveOnDemandErrorModule() throws (testing::TestError) {
3805
    let mut a = testResolver();
3806
    let rootId = try registerModule(
3807
        &mut super::MODULE_GRAPH, nil, "root", "export mod state; export mod timers;"
3808
    );
3809
    let stateId = try registerModule(
3810
        &mut super::MODULE_GRAPH,
3811
        rootId,
3812
        "state",
3813
        "use super::timers; record First { store: timers::Store } record Second { value: Missing }"
3814
    );
3815
    let timersId = try registerModule(
3816
        &mut super::MODULE_GRAPH, rootId, "timers", "export record Store { value: Absent }"
3817
    );
3818
    let result = try resolveModuleTree(&mut a, rootId);
3819
    let mut seen: u32 = 0;
3820
    for i in 0 .. result.diagnostics.errors.len {
3821
        let err = resolver::errorAt(&result.diagnostics.errors[..], i)
3822
            else throw testing::TestError::Failed;
3823
        if let case resolver::ErrorKind::UnresolvedSymbol(name) = err.kind {
3824
            if mem::eq(name, "Absent") {
3825
                try testing::expect(err.moduleId == timersId);
3826
                set seen += 1;
3827
            } else if mem::eq(name, "Missing") {
3828
                try testing::expect(err.moduleId == stateId);
3829
                set seen += 1;
3830
            }
3831
        }
3832
    }
3833
    try testing::expect(seen == 2);
3834
}
3835
3836
/// Direct type imports retain the declaring type and its visibility.
3837
@test unsafe fn directTypeImports() throws (testing::TestError) {
3838
    let mut a = testResolver();
3839
    let root = try registerModule(
3840
        &mut super::MODULE_GRAPH,
3841
        nil,
3842
        "root",
3843
        "export union Error: Copy { Bad } export record Item: Copy { x: u32 } mod child;"
3844
    );
3845
    try registerModule(
3846
        &mut super::MODULE_GRAPH,
3847
        root,
3848
        "child",
3849
        "use super::Error; use root::Item; fn f() -> Error { let i = Item { x: 1 }; return Error::Bad; }"
3850
    );
3851
    let result = try resolveModuleTree(&mut a, root);
3852
    try expectNoErrors(&result);
3853
}
3854
3855
/// A direct import is private unless the import has an export attribute.
3856
@test unsafe fn directTypeImportVisibility() throws (testing::TestError) {
3857
    for exported in [false, true] {
3858
        let mut a = testResolver();
3859
        let root = try registerModule(
3860
            &mut super::MODULE_GRAPH, nil, "root", "export mod types; export mod bridge; mod app;"
3861
        );
3862
        try registerModule(
3863
            &mut super::MODULE_GRAPH, root, "types", "export record Item: Copy { x: u32 }"
3864
        );
3865
        let bridge = "export use root::types::Item;"
3866
            if exported
3867
            else "use root::types::Item;";
3868
        try registerModule(&mut super::MODULE_GRAPH, root, "bridge", bridge);
3869
        try registerModule(
3870
            &mut super::MODULE_GRAPH,
3871
            root,
3872
            "app",
3873
            "use root::bridge; fn f() -> bridge::Item { return bridge::Item { x: 1 }; }"
3874
        );
3875
        let result = try resolveModuleTree(&mut a, root);
3876
        if exported {
3877
            try expectNoErrors(&result);
3878
        } else {
3879
            try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("Item"));
3880
        }
3881
    }
3882
}
3883
3884
/// A rejected test function points to its declaration in its defining module.
3885
@test unsafe fn testSignatureLocation() throws (testing::TestError) {
3886
    let mut a = testResolver();
3887
    let root = try registerModule(
3888
        &mut super::MODULE_GRAPH,
3889
        nil,
3890
        "root",
3891
        "mod cases; union E: Copy { Failed } record Info { func: fn() throws(E) } fn runner() { let i = Info { func: cases::bad }; }"
3892
    );
3893
    let cases = try registerModule(
3894
        &mut super::MODULE_GRAPH, root, "cases", "@test fn bad() { assert true; }"
3895
    );
3896
    let result = try resolveModuleTree(&mut a, root);
3897
    let err = try expectError(&result);
3898
    assert err.moduleId == cases;
3899
    let case resolver::ErrorKind::TestSignature(_) = err.kind else throw testing::TestError::Failed;
3900
    let node = err.node else throw testing::TestError::Failed;
3901
    let case ast::NodeValue::Ident(name) = node.value else throw testing::TestError::Failed;
3902
    assert mem::eq(name, "bad");
3903
}
3904
3905
/// An optional annotation applies to both arms of a nil-first conditional.
3906
@test unsafe fn testNilFirstConditionalAnnotation() throws (testing::TestError) {
3907
    try expectAnalyzeOk(
3908
        "union Rule: Copy { Return, Bounds } fn f(condition: bool) -> ?Rule { let rule: ?Rule = nil if condition else Rule::Return; return rule; }"
3909
    );
3910
}
3911
3912
/// Both annotated conditional arms must fit their common result type.
3913
@test unsafe fn testConditionalAnnotationArms() throws (testing::TestError) {
3914
    try expectAnalyzeOk(
3915
        "fn f(c: bool) -> ?u8 { let a: ?u8 = 7 if c else nil; return nil if c else a; }"
3916
    );
3917
    let mut a = testResolver();
3918
    let result = try resolveProgramStr(
3919
        &mut a, "fn f(c: bool) { let a: ?u8 = nil if c else true; }"
3920
    );
3921
    let error = try expectError(&result);
3922
    let case resolver::ErrorKind::TypeMismatch(_) = error.kind else {
3923
        throw testing::TestError::Failed;
3924
    };
3925
}
3926
3927
/// Record field limits produce a source diagnostic at the boundary.
3928
@test unsafe fn recordFieldLimit() throws (testing::TestError) {
3929
    let mut a = testResolver();
3930
    let valid = try resolveProgramStr(
3931
        &mut a,
3932
        "record R { a0: u8, a1: u8, a2: u8, a3: u8, a4: u8, a5: u8, a6: u8, a7: u8, a8: u8, a9: u8, a10: u8, a11: u8, a12: u8, a13: u8, a14: u8, a15: u8, a16: u8, a17: u8, a18: u8, a19: u8, a20: u8, a21: u8, a22: u8, a23: u8, a24: u8, a25: u8, a26: u8, a27: u8, a28: u8, a29: u8, a30: u8, a31: u8 }"
3933
    );
3934
    try expectNoErrors(&valid);
3935
    let mut b = testResolver();
3936
    let invalid = try resolveProgramStr(
3937
        &mut b,
3938
        "record R { a0: u8, a1: u8, a2: u8, a3: u8, a4: u8, a5: u8, a6: u8, a7: u8, a8: u8, a9: u8, a10: u8, a11: u8, a12: u8, a13: u8, a14: u8, a15: u8, a16: u8, a17: u8, a18: u8, a19: u8, a20: u8, a21: u8, a22: u8, a23: u8, a24: u8, a25: u8, a26: u8, a27: u8, a28: u8, a29: u8, a30: u8, a31: u8, a32: u8 }"
3939
    );
3940
    assert invalid.diagnostics.errors.len == 1;
3941
    assert invalid.diagnostics.errors[0].kind
3942
        == resolver::ErrorKind::LimitExceeded("too many fields in one record");
3943
    for source in [
3944
        "record R(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);",
3945
        "union U { V(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8) }",
3946
    ] {
3947
        let mut a = testResolver();
3948
        let result = try resolveProgramStr(&mut a, source);
3949
        let error = try expectError(&result);
3950
        assert error.kind == resolver::ErrorKind::LimitExceeded(
3951
            "too many fields in one record"
3952
        );
3953
    }
3954
}
3955
3956
/// Instances can use traits declared in a parent or a later sibling module.
3957
@test unsafe fn instanceTraitModuleOrder() throws (testing::TestError) {
3958
    let mut a = testResolver();
3959
    let root = try registerModule(
3960
        &mut super::MODULE_GRAPH,
3961
        nil,
3962
        "root",
3963
        "mod child; export mod sibling; export trait Visit { fn (&mut Visit) visit(value: u32); }"
3964
    );
3965
    try registerModule(
3966
        &mut super::MODULE_GRAPH,
3967
        root,
3968
        "child",
3969
        "use super::Visit; use super::sibling::Other; record State { value: u32 } instance Visit for State { fn (self: &mut State) visit(value: u32) { set self.value = value; } } instance Other for State { fn (self: &State) value() -> u32 { return self.value; } }"
3970
    );
3971
    try registerModule(
3972
        &mut super::MODULE_GRAPH,
3973
        root,
3974
        "sibling",
3975
        "export trait Other { fn (&Other) value() -> u32; }"
3976
    );
3977
    let result = try resolveModuleTree(&mut a, root);
3978
    try expectNoErrors(&result);
3979
    assert a.instances.len == 2;
3980
}
3981
3982
/// Constant projections require immutable data and an in-bounds array index.
3983
@test unsafe fn testInvalidConstantProjections() throws (testing::TestError) {
3984
    for source in [
3985
        "record S: Copy { n: u32 } static V: S = S { n: 2 }; fn f() { constant N: u32 = V.n; }",
3986
        "constant A: [u32; 2] = [2; 2]; constant N: u32 = A[2];",
3987
        "constant A: [u32; 0] = []; constant N: u32 = A[0];",
3988
    ] {
3989
        let mut res = testResolver();
3990
        let root = try registerModule(&mut super::MODULE_GRAPH, nil, "root", source);
3991
        let result = try resolveModuleTree(&mut res, root);
3992
        try expectErrorKind(&result, resolver::ErrorKind::ConstExprRequired);
3993
    }
3994
}
3995
3996
/// Files that a test package declares for `@embed`.
3997
constant EMBEDS: [module::Embed; 1] = [module::Embed { path: "data/text", bytes: "hello" }];
3998
3999
/// Resolve a package whose root declares `EMBEDS`.
4000
unsafe fn resolveEmbedding(res: &mut resolver::Resolver, root: *[u8], child: ?*[u8]) -> TestResult
4001
    throws (testing::TestError)
4002
{
4003
    let id = try registerModule(&mut super::MODULE_GRAPH, nil, "root", root);
4004
    if let code = child {
4005
        try registerModule(&mut super::MODULE_GRAPH, id, "child", code);
4006
    }
4007
    set super::MODULE_GRAPH.entries[id as u32].embeds = &EMBEDS[..];
4008
    return try resolveModuleTree(res, id);
4009
}
4010
4011
/// `@embed` is a string constant from the package root, in every module and in
4012
/// constant aggregates and function bodies.
4013
@test unsafe fn testEmbedDeclaredFile() throws (testing::TestError) {
4014
    let mut res = testResolver();
4015
    let result = try resolveEmbedding(
4016
        &mut res,
4017
        program(
4018
            &[
4019
                "mod child; record Data { bytes: *[u8] } ",
4020
                "constant TEXT: *[u8] = @embed(\"data/text\"); ",
4021
                "constant DATA: Data = Data { bytes: @embed(\"data/text\") }; ",
4022
                "fn text() -> *[u8] { return @embed(\"data/text\"); }",
4023
            ]
4024
        ),
4025
        "export constant TEXT: *[u8] = @embed(\"data/text\");"
4026
    );
4027
    try expectNoErrors(&result);
4028
    let case ast::NodeValue::Module(module) = result.root.value
4029
        else throw testing::TestError::Failed;
4030
    let case ast::NodeValue::ConstDecl(decl) = module.statements[2].value
4031
        else throw testing::TestError::Failed;
4032
    let case resolver::ConstValue::String(text) = resolver::constValueEntry(&res, decl.value)
4033
        else throw testing::TestError::Failed;
4034
    assert mem::eq(text, "hello");
4035
    let type = try typeOf(&res, decl.value);
4036
    try expectSliceType(type, false);
4037
}
4038
4039
/// `@embed` names a file that the package declares, with a string literal.
4040
@test unsafe fn testEmbedErrors() throws (testing::TestError) {
4041
    {
4042
        let mut res = testResolver();
4043
        let result = try resolveEmbedding(
4044
            &mut res, "constant TEXT: *[u8] = @embed(\"data/missing\");", nil
4045
        );
4046
        try expectErrorKind(&result, resolver::ErrorKind::Builtin(
4047
            resolver::BuiltinError::EmbedNotFound("data/missing")
4048
        ));
4049
    }
4050
    {
4051
        let mut res = testResolver();
4052
        let result = try resolveEmbedding(
4053
            &mut res,
4054
            "constant PATH: *[u8] = \"data/text\"; constant TEXT: *[u8] = @embed(PATH);",
4055
            nil
4056
        );
4057
        try expectErrorKind(&result, resolver::ErrorKind::Builtin(
4058
            resolver::BuiltinError::EmbedPath
4059
        ));
4060
    }
4061
}