lib/std/lang/resolver/tests/core.rad 161.9 KiB raw
1
//! Resolver tests: literals, bindings, arrays, slices, control flow, functions, records, operators,
2
//! and type inference.
3
4
use std::io;
5
use std::lang::ast;
6
use std::lang::module;
7
use std::lang::parser;
8
use std::lang::resolver;
9
use std::lang::resolver::tests::*;
10
use std::mem::heap;
11
use std::testing;
12
13
/// Resolved package declarations remain available without binding them again.
14
@test unsafe fn incrementalPackages() throws (testing::TestError) {
15
    let mut res = testResolver();
16
    let root = try registerModule(
17
        &mut super::MODULE_GRAPH, nil, "dep", "export fn answer() -> u32 { return 42; }"
18
    );
19
    let first = try resolveModuleTree(&mut res, root);
20
    try expectNoErrors(&first);
21
    let modules = res.moduleTable;
22
    let packages = [
23
        resolver::Pkg { rootEntry: &modules.entries[root as u32], rootAst: first.root }
24
    ];
25
    let symbols = res.symbols.len;
26
    let scopes = res.scopes.len;
27
    let second = try resolver::resolve(&mut res, modules, &packages[..]) catch {
28
        throw testing::TestError::Failed;
29
    };
30
    assert resolver::success(&second);
31
    assert res.symbols.len == symbols;
32
    assert res.scopes.len == scopes;
33
34
    // Appended modules cross a metadata page while the provider keeps its symbols.
35
    let mut entries: *mut [module::ModuleEntry] = &mut [];
36
    try! entries.resize(8, modules.entries[0], res.arena);
37
    let mut graph = module::moduleGraph(entries);
38
    set graph.entriesLen = modules.entries.len;
39
    set super::TEST_FRONTEND.arena.nextId = 4095;
40
    let client = try registerModule(
41
        &mut graph, nil, "app", "use dep; fn value() -> u32 { return dep::answer(); }"
42
    );
43
    let all = module::freeze(graph);
44
    let entry = &all.entries[client as u32];
45
    let rootAst = entry.ast else panic "incrementalPackages: missing client root";
46
    let appended = [packages[0], resolver::Pkg { rootEntry: entry, rootAst }];
47
    let extended = try resolver::resolve(&mut res, all, &appended[..]) catch {
48
        throw testing::TestError::Failed;
49
    };
50
    assert resolver::success(&extended);
51
    assert res.symbols.len > symbols;
52
    assert res.scopes.len > scopes;
53
}
54
55
// Tests ///////////////////////////////////////////////////////////////////////
56
57
/// Function signatures and constants resolve their declaration dependencies.
58
@test unsafe fn testSignatureConstantDependencies() throws (testing::TestError) {
59
    for program in [
60
        "fn f() -> [u8; N] { return [0; N]; } constant N: u32 = 4;",
61
        "constant N: u32 = BASE * 2; constant BASE: u32 = 2; fn f(a: &[u8; N]) -> u8 { return a[0]; }",
62
        "constant F: fn() -> [u8; N] = f; fn f() -> [u8; N] { return [0; N]; } constant N: u32 = 4;",
63
        "fn f(a: &mut [u8; N]) { set a[0] = 1; } constant N: u32 = 2;",
64
    ] {
65
        let mut res = testResolver();
66
        let result = try resolveProgramStr(&mut res, program);
67
        try expectNoErrors(&result);
68
    }
69
}
70
71
/// Cyclic constant dependencies produce a diagnostic.
72
@test unsafe fn testDeclarationCycles() throws (testing::TestError) {
73
    for program in [
74
        "constant N: u32 = N;",
75
        "constant N: u32 = M; constant M: u32 = N;",
76
        "fn f() -> [u8; N] { return [0; N]; } constant N: u32 = M; constant M: u32 = N;",
77
    ] {
78
        let mut res = testResolver();
79
        let result = try resolveProgramStr(&mut res, program);
80
        try expectErrorKind(&result, resolver::ErrorKind::DeclarationCycle("N"));
81
    }
82
}
83
84
@test unsafe fn testResolveLit() throws (testing::TestError) {
85
    let mut a = testResolver();
86
    let result = try resolveExprStr(&mut a, "true");
87
88
    try expectNoErrors(&result);
89
    try expectType(&a, result.root, resolver::Type::Bool);
90
}
91
92
@test unsafe fn testResolveStringLiteralType() throws (testing::TestError) {
93
    let mut a = testResolver();
94
    let result = try resolveExprStr(&mut a, "\"hello\"");
95
96
    try expectNoErrors(&result);
97
    let ty = try typeOf(&a, result.root);
98
    let elemTy = try expectSliceType(ty, false);
99
    try testing::expect(elemTy == resolver::Type::U8);
100
}
101
102
@test unsafe fn testResolveAsNumeric() throws (testing::TestError) {
103
    {
104
        let mut a = testResolver();
105
        let result = try resolveExprStr(&mut a, "1 as u32");
106
        try expectNoErrors(&result);
107
        try expectType(&a, result.root, resolver::Type::U32);
108
    }
109
    {
110
        let mut a = testResolver();
111
        let result = try resolveBlockStr(&mut a, "let x: u32 = 913; x as u8;");
112
        try expectNoErrors(&result);
113
114
        let x = try getBlockStmt(result.root, 1);
115
        try expectExprStmtType(&a, x, resolver::Type::U8);
116
    }
117
}
118
119
@test unsafe fn testResolveAsInvalid() throws (testing::TestError) {
120
    let mut a = testResolver();
121
    let result = try resolveProgramStr(&mut a, "true as u32");
122
123
    try expectErrorKind(
124
        &result,
125
        resolver::ErrorKind::InvalidAsCast(resolver::InvalidAsCast {
126
            from: resolver::Type::Bool,
127
            to: resolver::Type::U32,
128
        })
129
    );
130
}
131
132
@test unsafe fn testResolveAsUnionToInt() throws (testing::TestError) {
133
    let mut a = testResolver();
134
    let program = "union Color { Red } Color::Red as u32;";
135
    let result = try resolveProgramStr(&mut a, program);
136
    try expectNoErrors(&result);
137
138
    let red = try getBlockStmt(result.root, 1);
139
    try expectExprStmtType(&a, red, resolver::Type::U32);
140
}
141
142
@test unsafe fn testResolveBinding() throws (testing::TestError) {
143
    let mut a = testResolver();
144
    let result = try resolveBlockStr(&mut a, "let x: bool = true; x;");
145
    let stmt = try parser::tests::getBlockLastStmt(result.root);
146
147
    try expectNoErrors(&result);
148
    try expectType(&a, stmt, resolver::Type::Void);
149
    try expectExprStmtType(&a, stmt, resolver::Type::Bool);
150
151
    let case ast::NodeValue::ExprStmt(x) = stmt.value else throw testing::TestError::Failed;
152
153
    let sym = resolver::symbolFor(&a, x) else throw testing::TestError::Failed;
154
    let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*sym].data
155
        else throw testing::TestError::Failed;
156
    try testing::expect(valType == resolver::Type::Bool);
157
}
158
159
@test unsafe fn testResolveBindingInvalid() throws (testing::TestError) {
160
    let mut a = testResolver();
161
    let result = try resolveBlockStr(&mut a, "let x: i32 = true;");
162
    let err = try expectError(&result);
163
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Bool);
164
}
165
166
@test unsafe fn testResolveDuplicateBinding() throws (testing::TestError) {
167
    let mut a = testResolver();
168
    let result = try resolveBlockStr(&mut a, "let x: bool = true; let x: u8 = 1;");
169
    let stmt = try parser::tests::getBlockLastStmt(result.root);
170
    try expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("x"));
171
}
172
173
/// A local scope holds `MAX_LOCAL_SYMBOLS` locals, and one more overflows it.
174
@test unsafe fn testResolveLocalScopeLimit() throws (testing::TestError) {
175
    // One-letter names keep the generated programs short.
176
    let names: *[u8] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
177
    let template: *[u8] = "let ?: u8 = 0; ";
178
    static buf: [u8; 512] = [0; 512];
179
180
    // Pass 0 declares the limit, and pass 1 declares one more local.
181
    for pass in 0 .. 2 {
182
        let count = resolver::MAX_LOCAL_SYMBOLS + pass;
183
        let mut len: u32 = 0;
184
        for i in 0 .. count {
185
            for j in 0 .. template.len {
186
                if template[j] == '?' {
187
                    set buf[len] = names[i];
188
                } else {
189
                    set buf[len] = template[j];
190
                }
191
                set len += 1;
192
            }
193
        }
194
        let mut a = testResolver();
195
        let result = try resolveBlockStr(&mut a, &buf[.. len]);
196
        if pass == 0 {
197
            try expectNoErrors(&result);
198
        } else {
199
            try expectErrorKind(&result, resolver::ErrorKind::SymbolOverflow);
200
        }
201
    }
202
}
203
204
@test unsafe fn testResolveConstLiteralValue() throws (testing::TestError) {
205
    let mut a = testResolver();
206
    let program = "constant ANSWER: i32 = 42;";
207
    let result = try resolveProgramStr(&mut a, program);
208
    try expectNoErrors(&result);
209
210
    let constNode = try getBlockStmt(result.root, 0);
211
    let sym = resolver::symbolFor(&a, constNode) else throw testing::TestError::Failed;
212
    let case resolver::SymbolData::Constant { type: constType, .. } = a.symbols[*sym].data
213
        else throw testing::TestError::Failed;
214
    try testing::expect(constType == resolver::Type::I32);
215
}
216
217
/// Test that a constant of optional type keeps no folded value of its
218
/// initializer, so uses of the constant read the optional.
219
@test unsafe fn testResolveConstOptionalHasNoFoldedValue() throws (testing::TestError) {
220
    let programs: [*[u8]; 4] = [
221
        "constant U: ?u32 = 9;",
222
        "constant U: ?bool = true;",
223
        "constant U: ?u8 = 'a';",
224
        "constant U: ?*[u8] = \"hi\";",
225
    ];
226
    for program in programs {
227
        let mut a = testResolver();
228
        let result = try resolveProgramStr(&mut a, program);
229
        try expectNoErrors(&result);
230
231
        let constNode = try getBlockStmt(result.root, 0);
232
        let sym = resolver::symbolFor(&a, constNode) else throw testing::TestError::Failed;
233
        let case resolver::SymbolData::Constant { type: constType, value } = a.symbols[*sym].data
234
            else throw testing::TestError::Failed;
235
        let case resolver::Type::Optional(_) = constType else throw testing::TestError::Failed;
236
        try testing::expect(value == nil);
237
    }
238
}
239
240
@test unsafe fn testResolveConstRequiresConstantExpr() throws (testing::TestError) {
241
    let mut a = testResolver();
242
    let program = "fn value() -> i32 { return 1 } fn main() { constant ANSWER: i32 = value(); }";
243
    let result = try resolveProgramStr(&mut a, program);
244
    let err = try expectErrorKind(&result, resolver::ErrorKind::ConstExprRequired);
245
246
    let errNode = err.node else throw testing::TestError::Failed;
247
    let case ast::NodeValue::Call(_) = errNode.value else throw testing::TestError::Failed;
248
}
249
250
@test unsafe fn testResolveStaticLiteralValue() throws (testing::TestError) {
251
    let mut a = testResolver();
252
    let program = "static COUNTER: i32 = 0;";
253
    let result = try resolveProgramStr(&mut a, program);
254
    try expectNoErrors(&result);
255
256
    let staticNode = try getBlockStmt(result.root, 0);
257
    let sym = resolver::symbolFor(&a, staticNode) else throw testing::TestError::Failed;
258
    let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*sym].data
259
        else throw testing::TestError::Failed;
260
    try testing::expect(valType == resolver::Type::I32);
261
}
262
263
@test unsafe fn testResolveStaticRequiresConstantExpr() throws (testing::TestError) {
264
    let mut a = testResolver();
265
    let program = "fn seed() -> i32 { return 1; } static COUNTER: i32 = seed();";
266
    let result = try resolveProgramStr(&mut a, program);
267
    let err = try expectErrorKind(&result, resolver::ErrorKind::ConstExprRequired);
268
269
    let errNode = err.node else throw testing::TestError::Failed;
270
    let case ast::NodeValue::Call(_) = errNode.value else throw testing::TestError::Failed;
271
}
272
273
@test unsafe fn testSymbolStoresFnAttributes() throws (testing::TestError) {
274
    let mut a = testResolver();
275
    let program = "@default export fn f() { return; }";
276
    let result = try resolveProgramStr(&mut a, program);
277
    try expectNoErrors(&result);
278
279
    let scope = resolver::scopeFor(&a, result.root) else throw testing::TestError::Failed;
280
    let sym = resolver::findSymbolInScope(&a, scope, "f") else throw testing::TestError::Failed;
281
282
    try testing::expect(ast::hasAttribute(a.symbols[*sym].attrs, ast::Attribute::Export));
283
    try testing::expect(ast::hasAttribute(a.symbols[*sym].attrs, ast::Attribute::Default));
284
    try testing::expectNot(ast::hasAttribute(a.symbols[*sym].attrs, ast::Attribute::Extern));
285
}
286
287
@test unsafe fn testSymbolStoresRecordAttributes() throws (testing::TestError) {
288
    let mut a = testResolver();
289
    let program = "export record S { value: i32 }";
290
    let result = try resolveProgramStr(&mut a, program);
291
    try expectNoErrors(&result);
292
293
    let scope = resolver::scopeFor(&a, result.root) else throw testing::TestError::Failed;
294
    let sym = resolver::findSymbolInScope(&a, scope, "S") else throw testing::TestError::Failed;
295
296
    try testing::expect(ast::hasAttribute(a.symbols[*sym].attrs, ast::Attribute::Export));
297
    try testing::expectNot(ast::hasAttribute(a.symbols[*sym].attrs, ast::Attribute::Default));
298
}
299
300
@test unsafe fn testDefaultAttributeRejectedOnRecord() throws (testing::TestError) {
301
    let mut a = testResolver();
302
    let program = "@default record T { value: i32 }";
303
    let result = try resolveProgramStr(&mut a, program);
304
    try expectErrorKind(&result, resolver::ErrorKind::DefaultAttrOnlyOnFn);
305
}
306
307
@test unsafe fn testDefaultAttributeRejectedOnUnion() throws (testing::TestError) {
308
    let mut a = testResolver();
309
    let program = "@default union Result { Ok, Err }";
310
    let result = try resolveProgramStr(&mut a, program);
311
    try expectErrorKind(&result, resolver::ErrorKind::DefaultAttrOnlyOnFn);
312
}
313
314
/// The allocation error is declared with `@language`, and the resolver records it.
315
@test unsafe fn testLanguageAllocError() throws (testing::TestError) {
316
    let mut a = testResolver();
317
    let result = try resolveProgramStr(&mut a, "@language union AllocError: Copy { OutOfMemory }");
318
    try expectNoErrors(&result);
319
    try testing::expect(a.allocError <> nil);
320
}
321
322
/// A language declaration needs a name that the compiler knows.
323
@test unsafe fn testLanguageUnknownName() throws (testing::TestError) {
324
    let mut a = testResolver();
325
    let result = try resolveProgramStr(&mut a, "@language union Other: Copy { OutOfMemory }");
326
    try expectErrorKind(&result, resolver::ErrorKind::LanguageItemUnknown);
327
}
328
329
/// The allocation error is exactly `union AllocError: Copy { OutOfMemory }`, so that every
330
/// declaration of it is the same type.
331
@test unsafe fn testLanguageShape() throws (testing::TestError) {
332
    for program in [
333
        "@language union AllocError: Copy { Other }",
334
        "@language union AllocError: Copy { OutOfMemory, Other }",
335
        "@language union AllocError: Copy { OutOfMemory(u8) }",
336
        "@language union AllocError: Copy { OutOfMemory = 3 }",
337
        "@language union AllocError { OutOfMemory }",
338
        "@language union AllocError: Once { OutOfMemory }",
339
    ] {
340
        let mut a = testResolver();
341
        let result = try resolveProgramStr(&mut a, program);
342
        try expectErrorKind(&result, resolver::ErrorKind::LanguageItemShape);
343
        try testing::expect(a.allocError == nil);
344
    }
345
}
346
347
/// An `Allocator` provides elements with optional plain payloads, but not optional pointers.
348
@test unsafe fn testAllocatorOptionalElements() throws (testing::TestError) {
349
    {
350
        let mut a = testResolver();
351
        let result = try resolveProgramStr(
352
            &mut a,
353
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(a: &Allocator, xs: *mut [?u32]) throws (AllocError) { let mut ys = xs; try ys.append(nil, a); }"
354
        );
355
        try expectNoErrors(&result);
356
    }
357
    {
358
        let mut a = testResolver();
359
        let result = try resolveProgramStr(
360
            &mut a,
361
            "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} fn f(a: &Allocator, xs: *mut [?*u32]) throws (AllocError) { let mut ys = xs; try ys.append(nil, a); }"
362
        );
363
        try expectErrorKind(&result, resolver::ErrorKind::AllocatorElementNotPlain);
364
    }
365
}
366
367
/// Only a union can be a language declaration.
368
@test unsafe fn testLanguageMisplaced() throws (testing::TestError) {
369
    for program in [
370
        "@language record AllocError { value: u8 }",
371
        "@language trait AllocError { fn (&AllocError) f(); }",
372
        "@language fn AllocError() {}",
373
        "@language constant AllocError: u8 = 1;",
374
    ] {
375
        let mut a = testResolver();
376
        let result = try resolveProgramStr(&mut a, program);
377
        try expectErrorKind(&result, resolver::ErrorKind::LanguageItemMisplaced);
378
    }
379
}
380
381
/// `Heap` and `Allocator` are empty records declared with `@language`.
382
@test unsafe fn testLanguageHeapTypes() throws (testing::TestError) {
383
    let mut a = testResolver();
384
    let result = try resolveProgramStr(
385
        &mut a, "@language record Heap {} @language record Allocator {}"
386
    );
387
    try expectNoErrors(&result);
388
    let heap = a.heaps[resolver::HeapKind::Heap as u32];
389
    let allocator = a.heaps[resolver::HeapKind::Allocator as u32];
390
    try testing::expect(heap <> nil);
391
    try testing::expect(allocator <> nil);
392
    try testing::expect(heap <> allocator);
393
}
394
395
/// The heap types have no fields and no derives, and are records.
396
@test unsafe fn testLanguageHeapShape() throws (testing::TestError) {
397
    for program in [
398
        "@language record Heap { x: u8 }",
399
        "@language record Heap: Copy {}",
400
        "@language record Allocator { x: u8 }",
401
    ] {
402
        let mut a = testResolver();
403
        let result = try resolveProgramStr(&mut a, program);
404
        try expectErrorKind(&result, resolver::ErrorKind::LanguageItemShape);
405
    }
406
    for program in [
407
        "@language union Heap { A }",
408
        "@language union Allocator { A }",
409
    ] {
410
        let mut a = testResolver();
411
        let result = try resolveProgramStr(&mut a, program);
412
        try expectErrorKind(&result, resolver::ErrorKind::LanguageItemMisplaced);
413
    }
414
}
415
416
/// `Arena` and `Heap` name one type.
417
@test unsafe fn testLanguageArenaIsHeap() throws (testing::TestError) {
418
    let mut a = testResolver();
419
    let result = try resolveProgramStr(
420
        &mut a,
421
        "@intrinsic constant fn new(size: u32) -> Heap; @language record Arena {} @language record Heap {} static P: Heap = new(64); static Q: Arena = new(64); fn f(a: &Arena) {} fn g() { f(&P); f(&Q); }"
422
    );
423
    try expectNoErrors(&result);
424
    try testing::expect(a.heaps[resolver::HeapKind::Heap as u32] <> nil);
425
    {
426
        let mut b = testResolver();
427
        let bad = try resolveProgramStr(&mut b, "@language record Arena { x: u8 }");
428
        try expectErrorKind(&bad, resolver::ErrorKind::LanguageItemShape);
429
    }
430
}
431
432
/// Constant calls initialize top-level heap storage with a positive size.
433
@test unsafe fn testConstantHeapInitializers() throws (testing::TestError) {
434
    for body in [
435
        "static P: Heap = new(1);",
436
        "static P: Heap = new(64);",
437
        "constant P: Heap = new(64);",
438
        "constant N: u32 = 8; static P: Heap = new(N * 8);",
439
        "constant N: u32 = 8; constant P: Heap = new(N * 8);",
440
        "static P: Heap = new(64); static Q: Heap = new(64);",
441
    ] {
442
        let mut a = testResolver();
443
        let result = try resolveProgramStr(
444
            &mut a,
445
            program(
446
                &[
447
                    "@language record Heap {} ",
448
                    "@intrinsic constant fn new(size: u32) -> Heap; ", body,
449
                ]
450
            )
451
        );
452
        try expectNoErrors(&result);
453
    }
454
    {
455
        let mut a = testResolver();
456
        let result = try resolveProgramStr(
457
            &mut a,
458
            program(
459
                &[
460
                    "@language record Heap {} ",
461
                    "@intrinsic constant fn new(size: u32) -> Heap; ",
462
                    "static P: Heap = new(0);",
463
                ]
464
            )
465
        );
466
        try expectErrorKind(&result, resolver::ErrorKind::HeapCapacity);
467
    }
468
    {
469
        let mut a = testResolver();
470
        let result = try resolveProgramStr(
471
            &mut a,
472
            program(
473
                &[
474
                    "@language record Heap {} ",
475
                    "@intrinsic constant fn new(size: u32) -> Heap; ",
476
                    "static N: u32 = 64; static P: Heap = new(N);",
477
                ]
478
            )
479
        );
480
        try expectErrorKind(&result, resolver::ErrorKind::ConstExprRequired);
481
    }
482
}
483
484
/// Heap sizes must fit the byte-count type of the allocation function.
485
@test unsafe fn testConstantHeapCapacityRange() throws (testing::TestError) {
486
    for size in ["-1", "4294967296"] {
487
        let mut a = testResolver();
488
        let result = try resolveProgramStr(
489
            &mut a,
490
            program(
491
                &[
492
                    "@language record Heap {} ",
493
                    "@intrinsic constant fn new(size: u32) -> Heap; ",
494
                    "static P: Heap = new(", size, ");",
495
                ]
496
            )
497
        );
498
        let error = try expectError(&result);
499
        try expectTypeMismatch(error, resolver::Type::U32, resolver::Type::Int);
500
    }
501
}
502
503
/// Constant functions require an intrinsic declaration with a known signature.
504
@test unsafe fn testConstantFunctionDeclarations() throws (testing::TestError) {
505
    {
506
        let mut a = testResolver();
507
        let result = try resolveProgramStr(
508
            &mut a, "constant fn f() -> u32 { return 1; }"
509
        );
510
        try expectErrorKind(&result, resolver::ErrorKind::ConstantFunction(
511
            resolver::ConstantError::RequiresIntrinsic
512
        ));
513
    }
514
    for decl in [
515
        "@intrinsic constant fn unknown(size: u32) -> Heap;",
516
        "@intrinsic constant fn new(size: u64) -> Heap;",
517
        "@intrinsic constant fn new() -> Heap;",
518
        "@intrinsic constant fn new(a: u32, b: u32) -> Heap;",
519
        "@intrinsic constant fn new(size: u32) -> u32;",
520
        "@intrinsic constant fn new(size: u32) -> Heap throws (u8);",
521
        "@intrinsic unsafe constant fn new(size: u32) -> Heap;",
522
    ] {
523
        let mut a = testResolver();
524
        let result = try resolveProgramStr(&mut a, program(&[
525
            "@language record Heap {} ", decl
526
        ]));
527
        try expectErrorKind(&result, resolver::ErrorKind::ConstantFunction(
528
            resolver::ConstantError::InvalidIntrinsic
529
        ));
530
    }
531
}
532
533
/// A constant call needs a top-level initializer and has no runtime address.
534
@test unsafe fn testConstantFunctionContexts() throws (testing::TestError) {
535
    for body in [
536
        "fn f() { new(64); }",
537
        "fn f() { static P: Heap = new(64); }",
538
        "fn f() { constant P: Heap = new(64); }",
539
    ] {
540
        let mut a = testResolver();
541
        let result = try resolveProgramStr(
542
            &mut a,
543
            program(
544
                &[
545
                    "@language record Heap {} ",
546
                    "@intrinsic constant fn new(size: u32) -> Heap; ", body,
547
                ]
548
            )
549
        );
550
        try expectErrorKind(&result, resolver::ErrorKind::ConstantFunction(
551
            resolver::ConstantError::Context
552
        ));
553
    }
554
    for body in [
555
        "constant F: fn(u32) -> u32 = new;",
556
        "fn f() { let pointer = new; }",
557
        "fn f() { new; }",
558
    ] {
559
        let mut a = testResolver();
560
        let result = try resolveProgramStr(
561
            &mut a,
562
            program(
563
                &[
564
                    "@language record Heap {} ",
565
                    "@intrinsic constant fn new(size: u32) -> Heap; ", body,
566
                ]
567
            )
568
        );
569
        try expectErrorKind(&result, resolver::ErrorKind::ConstantFunction(
570
            resolver::ConstantError::Value
571
        ));
572
    }
573
}
574
575
/// A heap initializer must create valid heap storage.
576
@test unsafe fn testHeapStaticInitializer() throws (testing::TestError) {
577
    let mut a = testResolver();
578
    let bad = try resolveProgramStr(&mut a, "@language record Heap {} static P: Heap = 1;");
579
    try expectError(&bad);
580
}
581
582
/// Safe statics cannot reach heap handles through pointer targets.
583
@test unsafe fn testHeapStaticPointerTargets() throws (testing::TestError) {
584
    for body in [
585
        "record Box { h: *Heap } static P: ?*Box = nil;",
586
        "static P: ?**Box = nil; record Box { h: *Heap }",
587
        "record Box { h: *Allocator } static P: ?*Box = nil;",
588
        "record Box { h: *Scratch } static P: ?*Box = nil;",
589
        "record Box { next: ?*Box, h: *Heap } static P: ?*Box = nil;",
590
        "record A { b: ?*B } record B { a: ?*A, h: *Heap } static P: ?*A = nil;",
591
        "union Box { Empty, Handle(*Heap) } static P: ?*Box = nil;",
592
        "record Box { h: [*Heap; 1] } static P: ?*Box = nil;",
593
        "record Box { h: ?*Heap } fn f() { static P: ?*Box = nil; }",
594
    ] {
595
        let mut a = testResolver();
596
        let bad = try resolveScratch(&mut a, body);
597
        try expectErrorKind(&bad, resolver::ErrorKind::HeapStatic);
598
    }
599
    for body in [
600
        "record Box { h: *Heap } unsafe static P: ?*Box = nil;",
601
        "record Box { next: ?*Box, n: u32 } static P: ?*Box = nil;",
602
        "record A { b: ?*B } record B { a: ?*A } static P: ?*A = nil;",
603
    ] {
604
        let mut a = testResolver();
605
        let result = try resolveScratch(&mut a, body);
606
        try expectNoErrors(&result);
607
    }
608
}
609
610
/// Declarations for the tests of `Scratch`.
611
constant SCRATCH_DECLS: *[u8] =
612
    "@language union AllocError: Copy { OutOfMemory } @language record Heap {} @language record Allocator {} @language record Scratch {} @intrinsic constant fn new(size: u32) -> Scratch; ";
613
614
/// Resolve `body` after the declarations of the heap types.
615
unsafe fn resolveScratch(a: &mut resolver::Resolver, body: *[u8]) -> TestResult
616
    throws (testing::TestError)
617
{
618
    static PROGRAM: [u8; 512] = [0; 512];
619
    let mut length: u32 = 0;
620
    for byte in SCRATCH_DECLS {
621
        set PROGRAM[length] = byte;
622
        set length += 1;
623
    }
624
    for byte in body {
625
        set PROGRAM[length] = byte;
626
        set length += 1;
627
    }
628
    return try resolveProgramStr(a, &PROGRAM[.. length]);
629
}
630
631
/// `Scratch` is a distinct heap type that a constant initializer creates.
632
@test unsafe fn testScratchDeclaration() throws (testing::TestError) {
633
    let mut a = testResolver();
634
    let result = try resolveScratch(&mut a, "static F: Scratch = new(64);");
635
    try expectNoErrors(&result);
636
    let scratch = a.heaps[resolver::HeapKind::Scratch as u32];
637
    try testing::expect(scratch <> nil);
638
    try testing::expect(scratch <> a.heaps[resolver::HeapKind::Heap as u32]);
639
    try testing::expect(scratch <> a.heaps[resolver::HeapKind::Allocator as u32]);
640
    {
641
        let mut b = testResolver();
642
        let bad = try resolveProgramStr(&mut b, "@language record Scratch { x: u8 }");
643
        try expectErrorKind(&bad, resolver::ErrorKind::LanguageItemShape);
644
    }
645
    {
646
        let mut b = testResolver();
647
        let bad = try resolveProgramStr(&mut b, "@language union Scratch { A }");
648
        try expectErrorKind(&bad, resolver::ErrorKind::LanguageItemMisplaced);
649
    }
650
    {
651
        let mut b = testResolver();
652
        let bad = try resolveProgramStr(
653
            &mut b,
654
            "@language record Allocator {} @intrinsic constant fn new(size: u32) -> Allocator;"
655
        );
656
        try expectErrorKind(&bad, resolver::ErrorKind::ConstantFunction(
657
            resolver::ConstantError::InvalidIntrinsic
658
        ));
659
    }
660
    {
661
        let mut b = testResolver();
662
        let bad = try resolveScratch(&mut b, "fn f(s: Scratch) {}");
663
        try expectErrorKind(&bad, resolver::ErrorKind::HeapValue);
664
    }
665
}
666
667
/// A handle to a scratch heap can be used as an allocator, and no handle becomes one to a
668
/// scratch heap, or goes from a scratch heap to a heap.
669
@test unsafe fn testScratchConversions() throws (testing::TestError) {
670
    let mut a = testResolver();
671
    let result = try resolveScratch(
672
        &mut a, "fn g(a: &Allocator) {} fn f(s: &Scratch) { g(s); }"
673
    );
674
    try expectNoErrors(&result);
675
    for body in [
676
        "fn g(h: &Heap) {} fn f(s: &Scratch) { g(s); }",
677
        "fn g(s: &Scratch) {} fn f(h: &Heap) { g(h); }",
678
        "fn g(s: &Scratch) {} fn f(a: &Allocator) { g(a); }",
679
    ] {
680
        let mut b = testResolver();
681
        let bad = try resolveScratch(&mut b, body);
682
        try expectError(&bad);
683
    }
684
    // A cast between heap handles is invalid, even in unsafe code.
685
    for body in [
686
        "unsafe fn f(h: &Heap) { let s = h as &Scratch; }",
687
        "unsafe fn f(s: &Scratch) { let h = s as &Heap; }",
688
        "unsafe fn f(a: &Allocator) { let h = a as &Heap; }",
689
        "unsafe fn f(a: &Allocator) { let s = a as &Scratch; }",
690
        "unsafe fn f(h: *Heap) { let s = h as *Scratch; }",
691
    ] {
692
        let mut b = testResolver();
693
        let bad = try resolveScratch(&mut b, body);
694
        let err = try expectError(&bad);
695
        let case resolver::ErrorKind::InvalidAsCast(_) = err.kind
696
            else throw testing::TestError::Failed;
697
    }
698
}
699
700
/// A scratch heap grows plain elements, and refuses elements that hold pointers.
701
@test unsafe fn testScratchElements() throws (testing::TestError) {
702
    let mut a = testResolver();
703
    let result = try resolveScratch(
704
        &mut a,
705
        "fn f(s: &Scratch, xs: *mut [u32]) throws (AllocError) { let mut ys = xs; try ys.append(1, s); }"
706
    );
707
    try expectNoErrors(&result);
708
    for body in [
709
        "fn f(s: &Scratch, xs: *mut [*u32], p: *u32) throws (AllocError) { let mut ys = xs; try ys.append(p, s); }",
710
        "fn f(s: &Scratch, p: *u32) throws (AllocError) { let q = try s.new(p); }",
711
        // An unsafe pointer is not plain, or safe code could overwrite one by allocating over it.
712
        "fn f(s: &Scratch, p: *unsafe u32) throws (AllocError) { let q = try s.new(p); }",
713
        "fn f(s: &Scratch, p: *unsafe [u32]) throws (AllocError) { let q = try s.new(p); }",
714
        "fn f(s: &Scratch, p: ?*unsafe u32) throws (AllocError) { let q = try s.new(p); }",
715
        "record R: Copy { p: *unsafe u32 } fn f(s: &Scratch, r: R) throws (AllocError) { let q = try s.new(r); }",
716
        "fn f(s: &Scratch, xs: *mut [*unsafe u32], p: *unsafe u32) throws (AllocError) { let mut ys = xs; try ys.append(p, s); }",
717
        // A scratch heap converts to an allocator, so the allocator view has the same rule.
718
        "fn f(a: &Allocator, p: *unsafe u32) throws (AllocError) { let q = try a.new(p); }",
719
    ] {
720
        let mut b = testResolver();
721
        let bad = try resolveScratch(&mut b, body);
722
        try expectErrorKind(&bad, resolver::ErrorKind::AllocatorElementNotPlain);
723
    }
724
    // A heap never reuses its memory, so it holds unsafe pointers.
725
    let mut c = testResolver();
726
    let held = try resolveScratch(
727
        &mut c, "fn f(h: &Heap, p: *unsafe u32) throws (AllocError) { let q = try h.new(p); }"
728
    );
729
    try expectNoErrors(&held);
730
}
731
732
/// `reset` is an unsafe call without arguments on a scratch heap, through a handle or a place.
733
/// No other heap has it, and it throws nothing.
734
@test unsafe fn testScratchReset() throws (testing::TestError) {
735
    for body in [
736
        "fn f(s: &Scratch) { unsafe { s.reset(); } }",
737
        "fn f(s: *Scratch) { unsafe { s.reset(); } }",
738
        "fn f(s: &Scratch) { unsafe { (*s).reset(); } }",
739
        "static F: Scratch = new(64); fn f() { unsafe { F.reset(); } }",
740
    ] {
741
        let mut a = testResolver();
742
        let result = try resolveScratch(&mut a, body);
743
        try expectNoErrors(&result);
744
    }
745
    {
746
        let mut a = testResolver();
747
        let bad = try resolveScratch(&mut a, "fn f(s: &Scratch) { s.reset(); }");
748
        try expectErrorKind(&bad, resolver::ErrorKind::UnsafeCall);
749
    }
750
    {
751
        let mut a = testResolver();
752
        let bad = try resolveScratch(&mut a, "fn f(s: &Scratch) { unsafe { s.reset(1); } }");
753
        let err = try expectError(&bad);
754
        let case resolver::ErrorKind::FnArgCountMismatch(m) = err.kind
755
            else throw testing::TestError::Failed;
756
        try testing::expect(m.expected == 0 and m.actual == 1);
757
    }
758
    for body in [
759
        "fn f(h: &Heap) { unsafe { h.reset(); } }",
760
        "fn f(a: &Allocator) { unsafe { a.reset(); } }",
761
    ] {
762
        let mut a = testResolver();
763
        let bad = try resolveScratch(&mut a, body);
764
        let err = try expectError(&bad);
765
        let case resolver::ErrorKind::RecordFieldUnknown(_) = err.kind
766
            else throw testing::TestError::Failed;
767
    }
768
    {
769
        let mut a = testResolver();
770
        let bad = try resolveScratch(
771
            &mut a, "fn f(s: &Scratch) throws (AllocError) { unsafe { try s.reset(); } }"
772
        );
773
        try expectError(&bad);
774
    }
775
}
776
777
/// Safe mutable data cannot hold a slice or trait object, or a pointer that reaches one. Only
778
/// `unsafe` lifts this, and pointers to `opaque` and unsafe pointers are plain data.
779
@test unsafe fn testMutableDataHoldsSlice() throws (testing::TestError) {
780
    for program in [
781
        "static S: *[u8] = \"x\";",
782
        "static S: *mut [u8] = &mut [];",
783
        "static S: ?*[u8] = nil;",
784
        "static S: [[*[u8]; 2]; 2] = [[\"\", \"\"], [\"\", \"\"]];",
785
        "record R { s: *[u8] } static S: R = R { s: \"x\" };",
786
        "record R { s: *[u8] } static S: ?*R = nil;",
787
        "record R { s: *[u8] } static S: ?**R = nil;",
788
        "record N { next: ?*N, s: *[u8] } static S: ?*N = nil;",
789
        "union U { A(*[u8]), B } static S: U = U::B;",
790
        "trait T { fn (&T) f(); } static S: ?*opaque T = nil;",
791
        "fn f() { static S: *[u8] = \"x\"; }",
792
        "@default fn main(a: *mut [*[u8]; 4]) { }",
793
        "record R { s: *mut [u8] } @default fn main(a: *mut R) { }",
794
        "record N { next: ?*N, s: *[u8] } @default fn main(a: *mut [?*N; 2]) { }",
795
        "@default fn main(env: u64, a: *mut [u8; 4], b: *mut [*[u8]; 4]) { }",
796
    ] {
797
        let mut a = testResolver();
798
        let result = try resolveProgramStr(&mut a, program);
799
        try expectErrorKind(&result, resolver::ErrorKind::MutableDataHoldsSlice);
800
    }
801
    for program in [
802
        "static S: [*[u8]; 0] = [];",
803
        "static S: ?*u32 = nil;",
804
        "record N { next: ?*N, n: u32 } static S: ?*N = nil;",
805
        "record A { b: ?*B } record B { a: ?*A } static S: ?*A = nil;",
806
        "static S: ?*unsafe [u8] = nil;",
807
        "static S: ?*opaque = nil;",
808
        "fn g() {} constant S: fn() = g;",
809
        "constant S: *[u8] = \"x\";",
810
        "constant S: [*[u8]; 1] = [\"x\"];",
811
        "unsafe static S: *[u8] = \"x\";",
812
        "unsafe static S: *mut [u8] = undefined;",
813
        "@default unsafe fn main(a: *mut [*[u8]; 4]) { }",
814
        "record R { s: *mut [u8] } @default unsafe fn main(a: *mut R) { }",
815
        "@default fn main(a: *mut [?*u32; 4]) { }",
816
        "fn f(a: *mut [*[u8]; 4]) { }",
817
    ] {
818
        let mut a = testResolver();
819
        let result = try resolveProgramStr(&mut a, program);
820
        try expectNoErrors(&result);
821
    }
822
}
823
824
/// Whether the first union of `program` is mixed.
825
unsafe fn isMixed(program: *[u8]) -> bool throws (testing::TestError) {
826
    let mut a = testResolver();
827
    let result = try resolveProgramStr(&mut a, program);
828
    try expectNoErrors(&result);
829
    for nominal in &a.nominals[..] {
830
        if let case resolver::NominalType::Union(unionType) = nominal {
831
            return unionType.mixed;
832
        }
833
    }
834
    throw testing::TestError::Failed;
835
}
836
837
/// A union is mixed when its payloads do not share one shape and one of them has a slot. A union
838
/// that is all void, all plain, or has payloads of one shape is not.
839
@test unsafe fn testMixedUnionPredicate() throws (testing::TestError) {
840
    for program in [
841
        "union U { A(*u8), B(u32) }",
842
        "union U { A(*[u8]), B(u32), C }",
843
        "union U { A(*u8), B(*u32) }",
844
        "union U { A(?*u8), B(*u8) }",
845
        "union U { A([*u8; 2]), B([u32; 2]) }",
846
        "record R { p: *u8 } union U { A(R), B(u32) }",
847
        "union U { A(u32, *u8), B(*u8, u32) }",
848
        "union U: Copy { A(fn() -> u32), B(u32) }",
849
    ] {
850
        try testing::expect(try isMixed(program));
851
    }
852
    for program in [
853
        "union U { A(*u8), B(*u8) }",
854
        "union U { A(*u8), B }",
855
        "union U { A(*u8), B, C }",
856
        "union U { A(u32), B(u64) }",
857
        "union U { A, B }",
858
        "union U { A(*u8, u32), B(*u8, u32) }",
859
        "union U { A([*u8; 0]), B(u32) }",
860
    ] {
861
        try testing::expect(not try isMixed(program));
862
    }
863
}
864
865
/// A pattern of a mixed union binds its payloads by value, whatever the kind of reference.
866
@test unsafe fn testMixedUnionByReference() throws (testing::TestError) {
867
    for program in [
868
        "union U { A(*u8), B(u32) } fn f(u: &U) { match u { case U::B(n) => {} else => {} } }",
869
        "union U { A(*u8), B(u32) } fn f(u: &mut U) { match u { case U::B(n) => {} else => {} } }",
870
        "union U { A(*u8), B(u32) } fn f(u: &U) { match u { case U::A(p) => {} else => {} } }",
871
        "union U { A(*u8), B(u32) } fn f() { let mut u = U::B(1); match &mut u { case U::B(n) => {} else => {} } }",
872
        "union U { A(*u8), B(u32) } fn f() { let u = U::B(1); if let case U::B(n) = &u { } }",
873
        "union U { A(*u8), B(u32) } fn f() { let u = U::B(1); let case U::B(n) = &u else { return; }; }",
874
        "union U { A(*u8), B(u32) } fn f() { let u = U::B(1); while let case U::B(n) = &u { } }",
875
        "union U { A(*u8), B { n: u32 } } fn f(u: &U) { match u { case U::B { n } => {} else => {} } }",
876
        "union U { A(*u8), B(u32, u32) } fn f(u: &U) { match u { case U::B(1, n) => {} else => {} } }",
877
        "union U { A(*u8), B(u32) } record R { u: U } fn f(r: &R) { match r { case R { u: U::B(n) } => {} else => {} } }",
878
    ] {
879
        let mut a = testResolver();
880
        let result = try resolveProgramStr(&mut a, program);
881
        try expectErrorKind(&result, resolver::ErrorKind::MixedUnionByReference);
882
    }
883
    // By value, without bindings, and for unions that are not mixed, a reference is fine.
884
    for program in [
885
        "union U { A(*u8), B(u32) } fn f(u: U) { match u { case U::B(n) => {} case U::A(p) => {} } }",
886
        "union U { A(*u8), B(u32) } fn f(u: &U) { match u { case U::B(_) => {} else => {} } }",
887
        "union U { A(*u8), B(u32) } fn f(u: &U) { match u { case U::B(7) => {} else => {} } }",
888
        "union U { A(*u8), B(u32), C } fn f(u: &U) { match u { case U::C => {} else => {} } }",
889
        "union U { A(*u8), B(*u8) } fn f(u: &mut U) { match u { case U::B(p) => {} else => {} } }",
890
        "union U { A(u32), B(u64) } fn f(u: &mut U) { match u { case U::B(n) => {} else => {} } }",
891
        "union U { A(*u8), B } fn f(u: &mut U) { match u { case U::A(p) => {} else => {} } }",
892
    ] {
893
        let mut a = testResolver();
894
        let result = try resolveProgramStr(&mut a, program);
895
        try expectNoErrors(&result);
896
    }
897
}
898
899
/// Safe mutable data cannot hold a mixed union, but a constant can, since the verifier accepts
900
/// read-only data that holds one. Unsafe statics and unions that are not mixed can be mutable.
901
@test unsafe fn testMixedUnionData() throws (testing::TestError) {
902
    for program in [
903
        "union U { A(*u8), B(u32) } static S: U = U::B(1);",
904
        "union U { A(*u8), B(u32) } static S: ?*U = nil;",
905
        "union U { A(*u8), B(u32) } record R { u: U } static S: [R; 2] = undefined;",
906
        "union U { A(u32), B(*u8) } @default fn main(a: *mut U) { }",
907
    ] {
908
        let mut a = testResolver();
909
        let result = try resolveProgramStr(&mut a, program);
910
        try expectErrorKind(&result, resolver::ErrorKind::MutableDataHoldsSlice);
911
    }
912
    for program in [
913
        "union U { A(*u8), B(u32) } unsafe static S: U = undefined;",
914
        "union U { A(*u8), B(u32) } fn f(u: U) -> U { return u; }",
915
        "union U { A(*u8), B(*u8) } static S: ?*u32 = nil; constant C: u32 = 1;",
916
        "union U { A(u32), B(u64) } static S: U = U::B(1); constant C: U = U::A(1);",
917
        "union U { A, B(u32) } constant C: U = U::B(1);",
918
        "union U { A(*u8), B(u32) } constant C: U = U::B(1);",
919
        "union U { A(*u8), B(u32) } constant C: [U; 1] = [U::B(1)];",
920
        "union U { A(*u8), B(u32) } constant C: *[U] = &[U::B(1)];",
921
        "union U { A(*u8), B(u32) } constant C: ?U = nil;",
922
    ] {
923
        let mut a = testResolver();
924
        let result = try resolveProgramStr(&mut a, program);
925
        try expectNoErrors(&result);
926
    }
927
}
928
929
/// Growing a heap throws `AllocError`, so the program must declare it.
930
@test unsafe fn testHeapGrowthNeedsAllocError() throws (testing::TestError) {
931
    let mut a = testResolver();
932
    let result = try resolveProgramStr(
933
        &mut a,
934
        "@intrinsic constant fn new(size: u32) -> Heap; @language record Heap {} static P: Heap = new(64); fn f(xs: *mut [u32]) throws (u8) { let mut ys = xs; try ys.append(1, &P); }"
935
    );
936
    try expectErrorKind(&result, resolver::ErrorKind::MissingAllocError);
937
}
938
939
/// Declarations of the allocation error in different modules are one type, so an error
940
/// thrown through one is caught through the other.
941
@test unsafe fn testLanguageDeclarationsAreOneType() throws (testing::TestError) {
942
    let mut a = testResolver();
943
    let rootId = try registerModule(
944
        &mut super::MODULE_GRAPH, nil, "root", "mod first; mod second;"
945
    );
946
    try registerModule(
947
        &mut super::MODULE_GRAPH,
948
        rootId,
949
        "first",
950
        "@language export union AllocError: Copy { OutOfMemory } export fn pass() throws (AllocError) { throw AllocError::OutOfMemory; }"
951
    );
952
    try registerModule(
953
        &mut super::MODULE_GRAPH,
954
        rootId,
955
        "second",
956
        "use super::first; @language export union AllocError: Copy { OutOfMemory } fn relay() throws (AllocError) { try first::pass(); }"
957
    );
958
    let result = try resolveModuleTree(&mut a, rootId);
959
    try expectNoErrors(&result);
960
}
961
962
/// The default function may take an environment parameter, then storage parameters.
963
@test unsafe fn testDefaultStorageParamsAllowed() throws (testing::TestError) {
964
    for program in [
965
        "@default fn main() -> i32 { return 0; }",
966
        "record Env { n: u32 } @default fn main(env: *Env) -> i32 { return 0; }",
967
        "@default fn main(env: u64) -> i32 { return 0; }",
968
        "@default fn main(env: i64) -> i32 { return 0; }",
969
        "@default fn main(env: *opaque) -> i32 { return 0; }",
970
        "@default fn main(env: *u8, a: *mut [u8; 16]) -> i32 { return 0; }",
971
        "@default fn main(a: *mut [u8; 16]) -> i32 { return 0; }",
972
        "record Env { n: u32 } @default fn main(env: *Env, a: *mut [u8; 16]) -> i32 { return 0; }",
973
        "record Env { n: u32 } @default fn main(env: *Env, a: *mut [u8; 16], b: *mut [u32; 8]) -> i32 { return 0; }",
974
        "record P { tag: u8, value: u32 } record Env { n: u32 } @default fn main(env: *Env, a: *mut [P; 4], b: *mut [[u16; 3]; 2]) -> i32 { return 0; }",
975
        "@default fn main(a: *mut [u8; 16], b: *mut [i64; 2], c: *mut [u16; 1]) { }",
976
        "@default fn main(a: *mut [u8; 16]) { set a[0] = 1; }",
977
        "@default fn main(env: u64, a: *mut u8) -> i32 { return 0; }",
978
        "@default fn main(a: *mut u64) -> i32 { return 0; }",
979
    ] {
980
        let mut res = testResolver();
981
        let result = try resolveProgramStr(&mut res, program);
982
        try expectNoErrors(&result);
983
    }
984
}
985
986
/// A storage parameter may point to any type that is valid when zero-filled.
987
@test unsafe fn testDefaultStorageParamsZeroValid() throws (testing::TestError) {
988
    for program in [
989
        // Scalars, arrays of any length, and arrays of zero-valid items.
990
        "@default fn main(a: *mut bool) -> i32 { return 0; }",
991
        "@default fn main(a: *mut [bool; 8]) -> i32 { return 0; }",
992
        "@default fn main(a: *mut [bool; 0]) -> i32 { return 0; }",
993
        "@default fn main(a: *mut [[bool; 2]; 4]) -> i32 { return 0; }",
994
        // Optionals are nil when zero, with and without the pointer optimization.
995
        "@default fn main(a: *mut [?*u8; 4]) -> i32 { return 0; }",
996
        "@default fn main(a: *mut [?u8; 4]) -> i32 { return 0; }",
997
        "@default unsafe fn main(a: *mut [?*[u8]; 4]) -> i32 { return 0; }",
998
        "@default fn main(a: *mut ??u8) -> i32 { return 0; }",
999
        "record P { x: *u8 } @default fn main(a: *mut [?P; 4]) -> i32 { return 0; }",
1000
        "@default fn main(a: *mut ?fn(u32) -> u32) -> i32 { return 0; }",
1001
        // Slices are empty when zero.
1002
        "@default unsafe fn main(a: *mut [*[u8]; 4]) -> i32 { return 0; }",
1003
        "@default unsafe fn main(a: *mut *mut [u8]) -> i32 { return 0; }",
1004
        "@default unsafe fn main(a: *mut [*mut [u32]; 4]) -> i32 { return 0; }",
1005
        // Unions whose tag 0 variant has no payload or a zero-valid one.
1006
        "union U { A, B } @default fn main(a: *mut [U; 4]) -> i32 { return 0; }",
1007
        "union U { A, B(*u8) } @default fn main(a: *mut U) -> i32 { return 0; }",
1008
        "union U { A(u32), B(*u8) } @default unsafe fn main(a: *mut U) -> i32 { return 0; }",
1009
        "union U { A(?*u8), B(*u8) } @default unsafe fn main(a: *mut U) -> i32 { return 0; }",
1010
        "union U { A, B = 5 } @default fn main(a: *mut U) -> i32 { return 0; }",
1011
        "union U { A = 0b10, B = 0 } @default fn main(a: *mut U) -> i32 { return 0; }",
1012
        "union U { A = 2, B = 0, C(*u8) } @default fn main(a: *mut U) -> i32 { return 0; }",
1013
        // Records of zero-valid fields, nested records, and mixed storage.
1014
        "record R { ok: u8, flag: bool } @default fn main(a: *mut [R; 4]) -> i32 { return 0; }",
1015
        "record Entry { key: *[u8], next: ?*Entry, live: bool } @default unsafe fn main(a: *mut [Entry; 4]) -> i32 { return 0; }",
1016
        "record In { a: [u8; 4], b: ?*u8 } record Out { i: In, j: [In; 2], s: *[u8] } @default unsafe fn main(a: *mut Out) -> i32 { return 0; }",
1017
        "union V { Off, On(u32) } record Storage { ast: [u8; 64], table: [*[u8]; 16], entries: [?*u8; 8], flags: [bool; 8], mode: V } @default unsafe fn main(env: u64, s: *mut Storage) -> i32 { return 0; }",
1018
        "constant N: u32 = 8; record S { ast: [u8; N * 2], flags: [bool; N] } @default fn main(s: *mut S) -> i32 { return 0; }",
1019
        "record S { a: [u8; 4] } record T { b: [u32; 2] } @default fn main(s: *mut S, t: *mut T) -> i32 { return 0; }",
1020
        "record Empty {} @default fn main(s: *mut Empty) -> i32 { return 0; }",
1021
    ] {
1022
        let mut res = testResolver();
1023
        let result = try resolveProgramStr(&mut res, program);
1024
        try expectNoErrors(&result);
1025
    }
1026
}
1027
1028
/// A storage-like parameter of an ordinary function is an ordinary parameter.
1029
@test unsafe fn testStorageParamsOnOrdinaryFnUnchecked() throws (testing::TestError) {
1030
    for program in [
1031
        "fn f(a: *[u8; 4], b: &mut [bool; 2], c: *mut [*u8; 2], d: *mut [u8]) {}",
1032
        "fn f(env: u32, a: bool, b: *mut [?u8; 2]) {}",
1033
        "fn f(a: *mut [u8; 4]) {} @default fn main() -> i32 { return 0; }",
1034
        "fn f(a: *mut *u8, b: *mut fn()) {} @default fn main() -> i32 { return 0; }",
1035
    ] {
1036
        let mut res = testResolver();
1037
        let result = try resolveProgramStr(&mut res, program);
1038
        try expectNoErrors(&result);
1039
    }
1040
}
1041
1042
/// Parameters of the default function after the environment must be `*mut T`.
1043
@test unsafe fn testDefaultStorageParamShapeRejected() throws (testing::TestError) {
1044
    for program in [
1045
        "@default fn main(a: *[u8; 16]) -> i32 { return 0; }",
1046
        "@default fn main(a: &mut [u8; 16]) -> i32 { return 0; }",
1047
        "@default fn main(a: &[u8; 16]) -> i32 { return 0; }",
1048
        "@default fn main(a: *mut [u8]) -> i32 { return 0; }",
1049
        "@default fn main(a: *[u8]) -> i32 { return 0; }",
1050
        "@default fn main(a: *unsafe mut [u8; 16]) -> i32 { return 0; }",
1051
        "@default fn main(a: [u8; 16]) -> i32 { return 0; }",
1052
        "@default fn main(env: u64, a: *[u8; 16]) -> i32 { return 0; }",
1053
        "@default fn main(env: u64, a: &mut [u8; 16]) -> i32 { return 0; }",
1054
        "@default fn main(env: u64, a: *mut [u8]) -> i32 { return 0; }",
1055
        "@default fn main(env: u64, a: u32) -> i32 { return 0; }",
1056
        "@default fn main(env: u64, a: *u8) -> i32 { return 0; }",
1057
        "@default fn main(env: u64, a: *mut [u8; 4], b: u32) -> i32 { return 0; }",
1058
        "@default fn main(env: u64, e: u64, a: *mut [u8; 4]) -> i32 { return 0; }",
1059
        "record S { a: [u8; 4] } @default fn main(s: &mut S) -> i32 { return 0; }",
1060
        "record S { a: [u8; 4] } @default fn main(env: u64, s: &mut S) -> i32 { return 0; }",
1061
        "record S { a: [u8; 4] } @default fn main(env: u64, s: *S) -> i32 { return 0; }",
1062
        "record S { a: [u8; 4] } @default fn main(env: u64, s: *unsafe mut S) -> i32 { return 0; }",
1063
    ] {
1064
        let mut res = testResolver();
1065
        let result = try resolveProgramStr(&mut res, program);
1066
        try expectErrorKind(&result, resolver::ErrorKind::DefaultParamNotStorage) catch error {
1067
            io::print(program);
1068
            io::print("\n");
1069
            throw error;
1070
        };
1071
    }
1072
}
1073
1074
/// The environment parameter must be an immutable `*T` or a 64-bit integer.
1075
@test unsafe fn testDefaultEnvParamShapeRejected() throws (testing::TestError) {
1076
    for program in [
1077
        "record S { n: u32 } @default fn main(s: S) -> i32 { return 0; }",
1078
        "@default fn main(env: u32) -> i32 { return 0; }",
1079
        "@default fn main(env: i32) -> i32 { return 0; }",
1080
        "@default fn main(env: u8) -> i32 { return 0; }",
1081
        "@default fn main(env: bool) -> i32 { return 0; }",
1082
        "record Env { n: u32 } @default fn main(env: &Env) -> i32 { return 0; }",
1083
        "record Env { n: u32 } @default fn main(env: *unsafe Env) -> i32 { return 0; }",
1084
        "record Env { n: u32 } @default fn main(env: ?*Env) -> i32 { return 0; }",
1085
        "@default fn main(env: fn()) -> i32 { return 0; }",
1086
        "record S { n: u32 } @default fn main(s: S, a: *mut [u8; 16]) -> i32 { return 0; }",
1087
    ] {
1088
        let mut res = testResolver();
1089
        let result = try resolveProgramStr(&mut res, program);
1090
        try expectErrorKind(&result, resolver::ErrorKind::DefaultEnvInvalid) catch error {
1091
            io::print(program);
1092
            io::print("\n");
1093
            throw error;
1094
        };
1095
    }
1096
}
1097
1098
/// Storage parameters must point to a type that is valid when zero-filled.
1099
@test unsafe fn testDefaultStorageParamElementRejected() throws (testing::TestError) {
1100
    for program in [
1101
        // Non-optional pointers and references.
1102
        "@default fn main(a: *mut *u8) -> i32 { return 0; }",
1103
        "@default fn main(a: *mut *mut u8) -> i32 { return 0; }",
1104
        "@default fn main(a: *mut [*u8; 4]) -> i32 { return 0; }",
1105
        "@default fn main(a: *mut [*mut u8; 4]) -> i32 { return 0; }",
1106
        "@default fn main(a: *mut [*unsafe u8; 4]) -> i32 { return 0; }",
1107
        "record R { p: *u8 } @default fn main(a: *mut R) -> i32 { return 0; }",
1108
        "record R { n: u32, p: *u8 } @default fn main(a: *mut [R; 4]) -> i32 { return 0; }",
1109
        // Functions and trait objects.
1110
        "@default fn main(a: *mut fn()) -> i32 { return 0; }",
1111
        "record R { f: fn(u32) -> u32 } @default fn main(a: *mut R) -> i32 { return 0; }",
1112
        "trait T { fn (&T) f(); } @default fn main(a: *mut *opaque T) -> i32 { return 0; }",
1113
        "trait T { fn (&T) f(); } record R { t: *opaque T } @default fn main(a: *mut R) -> i32 { return 0; }",
1114
        // Linear types.
1115
        "record L: Once { n: u32 } @default fn main(a: *mut L) -> i32 { return 0; }",
1116
        "record L: Once { n: u32 } @default fn main(a: *mut [L; 2]) -> i32 { return 0; }",
1117
        "record L: Once { n: u32 } record R { l: L } @default fn main(a: *mut R) -> i32 { return 0; }",
1118
        "record L: Once { n: u32 } @default fn main(a: *mut ?L) -> i32 { return 0; }",
1119
        "record L: Once { n: u32 } union U { A, B(L) } @default fn main(a: *mut U) -> i32 { return 0; }",
1120
        // Unions without a zero tag, or with an invalid payload at tag 0.
1121
        "union U { A = 1, B = 2 } @default fn main(a: *mut U) -> i32 { return 0; }",
1122
        "union U { A = 0b10, B } @default fn main(a: *mut U) -> i32 { return 0; }",
1123
        "union U { A(*u8), B } @default fn main(a: *mut U) -> i32 { return 0; }",
1124
        "union U { A(*u8), B } @default fn main(a: *mut [U; 4]) -> i32 { return 0; }",
1125
        "union U { A(fn()), B(u32) } record R { u: U } @default fn main(a: *mut R) -> i32 { return 0; }",
1126
        "union U { B = 3, A(*[u8]), C(u8) } @default fn main(a: *mut U) -> i32 { return 0; }",
1127
        // Types that are not values with a zero form.
1128
        "@default fn main(a: *mut opaque) -> i32 { return 0; }",
1129
        "record Env { n: u32 } @default fn main(env: *Env, a: *mut [u8; 4], b: *mut *u8) -> i32 { return 0; }",
1130
        "record S { a: [u8; 4], p: [*u8; 2] } @default fn main(s: *mut S) -> i32 { return 0; }",
1131
    ] {
1132
        let mut res = testResolver();
1133
        let result = try resolveProgramStr(&mut res, program);
1134
        try expectErrorKind(&result, resolver::ErrorKind::DefaultStorageNotZeroValid) catch error {
1135
            io::print(program);
1136
            io::print("\n");
1137
            throw error;
1138
        };
1139
    }
1140
}
1141
1142
/// A record storage parameter splits into owned slices by field, once per field.
1143
@test unsafe fn testDefaultStorageFieldsSplit() throws (testing::TestError) {
1144
    for program in [
1145
        "record S { ast: [u8; 16], table: [?*u8; 4], n: u32 } @default fn main(s: *mut S) -> i32 { let a: *mut [u8] = &mut s.ast[..]; let t: *mut [?*u8] = &mut s.table[..]; return 0; }",
1146
        "record S { ast: [u8; 16], table: [?*u8; 4], n: u32 } @default fn main(env: u64, s: *mut S) -> i32 { let t: *mut [?*u8] = &mut s.table[..]; let a: *mut [u8] = &mut s.ast[..]; set s.n = 1; return 0; }",
1147
    ] {
1148
        let mut res = testResolver();
1149
        let result = try resolveProgramStr(&mut res, program);
1150
        try expectNoErrors(&result);
1151
    }
1152
}
1153
1154
/// A field of a record storage parameter moves once, and the record moves as a whole.
1155
@test unsafe fn testDefaultStorageFieldsSplitRejected() throws (testing::TestError) {
1156
    for program in [
1157
        "record S { ast: [u8; 16], table: [?*u8; 4] } @default fn main(s: *mut S) -> i32 { let a: *mut [u8] = &mut s.ast[..]; let b: *mut [u8] = &mut s.ast[..]; return 0; }",
1158
        "record S { ast: [u8; 16], table: [?*u8; 4] } fn eat(s: *mut S) {} @default fn main(s: *mut S) -> i32 { let a: *mut [u8] = &mut s.ast[..]; eat(s); return 0; }",
1159
        "record S { ast: [u8; 16], table: [?*u8; 4] } @default fn main(s: *mut S) -> i32 { let a: *mut [u8] = &mut s.ast[..]; return s.ast[0] as i32; }",
1160
    ] {
1161
        let mut res = testResolver();
1162
        let result = try resolveProgramStr(&mut res, program);
1163
        let err = try expectError(&result);
1164
        let case resolver::ErrorKind::AffineUseAfterMove(_) = err.kind
1165
            else throw testing::TestError::Failed;
1166
    }
1167
}
1168
1169
@test unsafe fn testResolveArrayLiteralTyped() throws (testing::TestError) {
1170
    let mut a = testResolver();
1171
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2];");
1172
    try expectNoErrors(&result);
1173
1174
    let stmt = try getBlockStmt(result.root, 0);
1175
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1176
    let arrayTy = try typeOf(&a, decl.value);
1177
    let elemTy = try expectArrayType(arrayTy, 2);
1178
    try testing::expect(elemTy == resolver::Type::I32);
1179
}
1180
1181
@test unsafe fn testResolveArrayLiteralElementMismatch() throws (testing::TestError) {
1182
    let mut a = testResolver();
1183
    let result = try resolveProgramStr(&mut a, "let xs: [bool; 2] = [true, 1];");
1184
    let err = try expectError(&result);
1185
    try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
1186
}
1187
1188
@test unsafe fn testResolveArrayLiteralCannotInfer() throws (testing::TestError) {
1189
    let mut a = testResolver();
1190
    let result = try resolveProgramStr(&mut a, "let xs = [1, 2];");
1191
    try expectErrorKind(&result, resolver::ErrorKind::CannotInferType);
1192
}
1193
1194
@test unsafe fn testResolveArrayLiteralOverflow() throws (testing::TestError) {
1195
    let mut a = testResolver();
1196
    let result = try resolveProgramStr(&mut a, "let xs: [u8; 2] = [1, 256];");
1197
    let err = try expectError(&result);
1198
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1199
}
1200
1201
@test unsafe fn testResolveArrayLiteralTooFewElements() throws (testing::TestError) {
1202
    let mut a = testResolver();
1203
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1];");
1204
    let err = try expectError(&result);
1205
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1206
}
1207
1208
@test unsafe fn testResolveArrayLiteralTooManyElements() throws (testing::TestError) {
1209
    let mut a = testResolver();
1210
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 2] = [1, 2, 3];");
1211
    let err = try expectError(&result);
1212
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1213
}
1214
1215
@test unsafe fn testResolveArrayLiteralEmptyWithAnnotation() throws (testing::TestError) {
1216
    let mut a = testResolver();
1217
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 0] = [];");
1218
    try expectNoErrors(&result);
1219
}
1220
1221
@test unsafe fn testResolveNestedArrayLiteralTyped() throws (testing::TestError) {
1222
    let mut a = testResolver();
1223
    let result = try resolveProgramStr(&mut a, "let grid: [[i32; 2]; 2] = [[1, 2], [3, 4]];");
1224
    try expectNoErrors(&result);
1225
1226
    let stmt = try getBlockStmt(result.root, 0);
1227
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1228
    let gridTy = try typeOf(&a, decl.value);
1229
    let rowTy = try expectArrayType(gridTy, 2);
1230
    let elemTy = try expectArrayType(rowTy, 2);
1231
    try testing::expect(elemTy == resolver::Type::I32);
1232
}
1233
1234
@test unsafe fn testResolveArrayLiteralWithOptionalElems() throws (testing::TestError) {
1235
    let mut a = testResolver();
1236
    let result = try resolveProgramStr(&mut a, "let xs: [?i32; 2] = [1, 2];");
1237
    try expectNoErrors(&result);
1238
1239
    let stmt = try getBlockStmt(result.root, 0);
1240
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1241
    let arrayTy = try typeOf(&a, decl.value);
1242
    let elemTy = try expectArrayType(arrayTy, 2);
1243
    let case resolver::Type::Optional(inner) = elemTy else throw testing::TestError::Failed;
1244
    try testing::expect(*inner == resolver::Type::I32);
1245
}
1246
1247
@test unsafe fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
1248
    let mut a = testResolver();
1249
    let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");
1250
    let err = try expectError(&result);
1251
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1252
}
1253
1254
/// Test that a union constructor bound to an optional keeps the union type,
1255
/// and that the binding has the optional type with an `OptionalLift` coercion.
1256
@test unsafe fn testResolveLetOptionalUnionConstructor() throws (testing::TestError) {
1257
    let programs: [*[u8]; 4] = [
1258
        "union U: Copy { A(u32), B } let x: ?U = U::A(4);",
1259
        "union U: Copy { A(u32), B } let x: ?U = U::B;",
1260
        "union U: Copy { A { w: u32, h: u32 }, B } let x: ?U = U::A { w: 1, h: 2 };",
1261
        "union U { A(*[u8]), B } let x: ?U = U::A(\"s\");",
1262
    ];
1263
    for program in programs {
1264
        let mut a = testResolver();
1265
        let result = try resolveProgramStr(&mut a, program);
1266
        try expectNoErrors(&result);
1267
1268
        let stmt = try getBlockStmt(result.root, 1);
1269
        let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1270
        let valueTy = try typeOf(&a, decl.value);
1271
        let case resolver::Type::Nominal(_) = valueTy else throw testing::TestError::Failed;
1272
1273
        let sym = resolver::symbolFor(&a, stmt) else throw testing::TestError::Failed;
1274
        let case resolver::SymbolData::Value { type: bindingTy, .. } = a.symbols[*sym].data
1275
            else throw testing::TestError::Failed;
1276
        let case resolver::Type::Optional(inner) = bindingTy else throw testing::TestError::Failed;
1277
        try testing::expect(resolver::typesEqual(&a, *inner, valueTy));
1278
1279
        let coercion = resolver::coercionFor(&a, decl.value) else throw testing::TestError::Failed;
1280
        let case resolver::Coercion::OptionalLift { target, .. } = coercion
1281
            else throw testing::TestError::Failed;
1282
        try testing::expect(resolver::typesEqual(&a, target, bindingTy));
1283
    }
1284
}
1285
1286
/// Test that a value that is not lifted takes the binding type.
1287
@test unsafe fn testResolveLetValueTakesBindingType() throws (testing::TestError) {
1288
    let mut a = testResolver();
1289
    let result = try resolveProgramStr(&mut a, "let x: i64 = 5;");
1290
    try expectNoErrors(&result);
1291
1292
    let stmt = try getBlockStmt(result.root, 0);
1293
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1294
    try testing::expect(try typeOf(&a, decl.value) == resolver::Type::I64);
1295
}
1296
1297
@test unsafe fn testResolveArrayRepeatBasic() throws (testing::TestError) {
1298
    let mut a = testResolver();
1299
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3];");
1300
    try expectNoErrors(&result);
1301
1302
    let stmt = try getBlockStmt(result.root, 0);
1303
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1304
    let arrayTy = try typeOf(&a, decl.value);
1305
    let elemTy = try expectArrayType(arrayTy, 3);
1306
    try testing::expect(elemTy == resolver::Type::I32);
1307
}
1308
1309
@test unsafe fn testResolveArrayRepeatWithExpression() throws (testing::TestError) {
1310
    let mut a = testResolver();
1311
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 5] = [3 + 2; 5];");
1312
    try expectNoErrors(&result);
1313
1314
    let stmt = try getBlockStmt(result.root, 0);
1315
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1316
    let arrayTy = try typeOf(&a, decl.value);
1317
    let elemTy = try expectArrayType(arrayTy, 5);
1318
    try testing::expect(elemTy == resolver::Type::I32);
1319
}
1320
1321
/// Test that the repeated item of a repeat literal gets the `OptionalLift`
1322
/// coercion, and that the array has the optional element type and no
1323
/// coercion.
1324
@test unsafe fn testResolveArrayRepeatOptionalItem() throws (testing::TestError) {
1325
    let mut a = testResolver();
1326
    let result = try resolveProgramStr(&mut a, "let xs: [?i32; 3] = [42; 3];");
1327
    try expectNoErrors(&result);
1328
1329
    let stmt = try getBlockStmt(result.root, 0);
1330
    let case ast::NodeValue::Let(decl) = stmt.value else throw testing::TestError::Failed;
1331
    let case ast::NodeValue::ArrayRepeatLit(repeat) = decl.value.value
1332
        else throw testing::TestError::Failed;
1333
    let arrayTy = try typeOf(&a, decl.value);
1334
    let elemTy = try expectArrayType(arrayTy, 3);
1335
    let case resolver::Type::Optional(inner) = elemTy else throw testing::TestError::Failed;
1336
    try testing::expect(*inner == resolver::Type::I32);
1337
1338
    let coercion = resolver::coercionFor(&a, repeat.item) else throw testing::TestError::Failed;
1339
    let case resolver::Coercion::OptionalLift { target, .. } = coercion
1340
        else throw testing::TestError::Failed;
1341
    try testing::expect(resolver::typesEqual(&a, target, elemTy));
1342
    try testing::expect(resolver::coercionFor(&a, decl.value) == nil);
1343
}
1344
1345
/// Test that a repeat literal of unsuffixed integers returned from a function
1346
/// has the element type of the return type.
1347
@test unsafe fn testResolveArrayRepeatReturnElementType() throws (testing::TestError) {
1348
    let mut a = testResolver();
1349
    let result = try resolveProgramStr(&mut a, "fn f() -> [u8; 3] { return [200; 3]; }");
1350
    try expectNoErrors(&result);
1351
1352
    let fnNode = try getBlockStmt(result.root, 0);
1353
    let case ast::NodeValue::FnDecl(decl) = fnNode.value else throw testing::TestError::Failed;
1354
    let body = decl.body else throw testing::TestError::Failed;
1355
    let case ast::NodeValue::Block(block) = body.value else throw testing::TestError::Failed;
1356
    let case ast::NodeValue::Return { value } = block.statements[0].value
1357
        else throw testing::TestError::Failed;
1358
    let retValue = value else throw testing::TestError::Failed;
1359
    let elemTy = try expectArrayType(try typeOf(&a, retValue), 3);
1360
    try testing::expect(elemTy == resolver::Type::U8);
1361
}
1362
1363
@test unsafe fn testResolveArrayRepeatLiteralArithmetic() throws (testing::TestError) {
1364
    let mut a = testResolver();
1365
    // `3 * 1` folds to a compile-time constant, so the repeat count is valid.
1366
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 3] = [42; 3 * 1];");
1367
    try expectNoErrors(&result);
1368
}
1369
1370
@test unsafe fn testResolveArrayRepeatNonConstCount() throws (testing::TestError) {
1371
    let mut a = testResolver();
1372
    // A function call is not a constant expression.
1373
    let result = try resolveProgramStr(
1374
        &mut a, "fn f() -> u32 { return 3; } let xs: [i32; 3] = [42; f()];"
1375
    );
1376
    try expectErrorKind(&result, resolver::ErrorKind::ConstExprRequired);
1377
}
1378
1379
@test unsafe fn testResolveArrayRepeatCountMismatch() throws (testing::TestError) {
1380
    let mut a = testResolver();
1381
    let result = try resolveProgramStr(&mut a, "let xs: [i32; 4] = [1; 3];");
1382
    let err = try expectError(&result);
1383
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1384
}
1385
1386
@test unsafe fn testResolveArrayIndex() throws (testing::TestError) {
1387
    let mut a = testResolver();
1388
    let program = "let xs: [i32; 3] = [1, 2, 3]; xs[1];";
1389
    let result = try resolveProgramStr(&mut a, program);
1390
    try expectNoErrors(&result);
1391
1392
    let stmt = try getBlockStmt(result.root, 1);
1393
    try expectExprStmtType(&a, stmt, resolver::Type::I32);
1394
}
1395
1396
@test unsafe fn testResolveSliceIndex() throws (testing::TestError) {
1397
    let mut a = testResolver();
1398
    let program = "static xs: [i32; 4] = [1, 2, 3, 4]; let slice = &xs[1..]; slice[1];";
1399
    let result = try resolveProgramStr(&mut a, program);
1400
    try expectNoErrors(&result);
1401
1402
    let sliceStmt = try getBlockStmt(result.root, 1);
1403
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value else throw testing::TestError::Failed;
1404
    let sliceTy = try typeOf(&a, sliceDecl.value);
1405
    let elemTy = try expectSliceType(sliceTy, false);
1406
    try testing::expect(elemTy == resolver::Type::I32);
1407
1408
    let indexStmt = try getBlockStmt(result.root, 2);
1409
    try expectExprStmtType(&a, indexStmt, resolver::Type::I32);
1410
}
1411
1412
@test unsafe fn testResolveSliceFields() throws (testing::TestError) {
1413
    let mut a = testResolver();
1414
    let program =
1415
        "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[1..]; slice.len; unsafe { slice.ptr; }";
1416
    let result = try resolveProgramStr(&mut a, program);
1417
    try expectNoErrors(&result);
1418
1419
    let lenStmt = try getBlockStmt(result.root, 2);
1420
    let case ast::NodeValue::ExprStmt(lenExpr) = lenStmt.value
1421
        else throw testing::TestError::Failed;
1422
    let lenTy = try typeOf(&a, lenExpr);
1423
    try testing::expect(lenTy == resolver::Type::U32);
1424
1425
    let ptrStmt = try getBlockStmt(result.root, 3);
1426
    let case ast::NodeValue::Block(ptrBlock) = ptrStmt.value else throw testing::TestError::Failed;
1427
    let case ast::NodeValue::ExprStmt(ptrExpr) = ptrBlock.statements[0].value
1428
        else throw testing::TestError::Failed;
1429
    let ptrTy = try typeOf(&a, ptrExpr);
1430
    let targetTy = try expectPointerType(ptrTy, false);
1431
    try testing::expect(targetTy == resolver::Type::I32);
1432
}
1433
1434
@test unsafe fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
1435
    let mut a = testResolver();
1436
    let program = "let slice: *[i32] = &[1, 2, 3];";
1437
    let result = try resolveProgramStr(&mut a, program);
1438
    try expectNoErrors(&result);
1439
}
1440
1441
/// Empty array literal infers element type from slice annotation.
1442
@test unsafe fn testResolveSliceLiteralEmpty() throws (testing::TestError) {
1443
    let mut a = testResolver();
1444
    let program = "let slice: *[i32] = &[];";
1445
    let result = try resolveProgramStr(&mut a, program);
1446
    try expectNoErrors(&result);
1447
}
1448
1449
/// Nested array literal should infer inner element type from slice annotation.
1450
@test unsafe fn testResolveSliceLiteralNestedArray() throws (testing::TestError) {
1451
    let mut a = testResolver();
1452
    let program = "let slice: *[[i32; 2]] = &[[1, 2], [3, 4]];";
1453
    let result = try resolveProgramStr(&mut a, program);
1454
    try expectNoErrors(&result);
1455
}
1456
1457
@test unsafe fn testResolveSliceFromArray() throws (testing::TestError) {
1458
    {
1459
        let mut a = testResolver();
1460
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
1461
        let result = try resolveProgramStr(&mut a, program);
1462
        try expectNoErrors(&result);
1463
    }
1464
    {
1465
        let mut a = testResolver();
1466
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
1467
        let result = try resolveProgramStr(&mut a, program);
1468
        try expectNoErrors(&result);
1469
    }
1470
    {
1471
        let mut a = testResolver();
1472
        let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
1473
        let result = try resolveProgramStr(&mut a, program);
1474
        try expectNoErrors(&result);
1475
    }
1476
    {
1477
        let mut a = testResolver();
1478
        let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
1479
        let result = try resolveProgramStr(&mut a, program);
1480
        try expectNoErrors(&result);
1481
    }
1482
}
1483
1484
@test unsafe fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
1485
    let mut a = testResolver();
1486
    let program = "let slice: *mut [i32] = &[1, 2, 3];";
1487
    let result = try resolveProgramStr(&mut a, program);
1488
    let err = try expectError(&result);
1489
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1490
}
1491
1492
@test unsafe fn testResolveSliceLiteralMutable() throws (testing::TestError) {
1493
    let mut a = testResolver();
1494
    let program = "unsafe { let slice: *mut [i32] = &mut [1, 2, 3]; }";
1495
    let result = try resolveProgramStr(&mut a, program);
1496
    try expectNoErrors(&result);
1497
}
1498
1499
/// A mutable constant array is a fresh temporary in safe code, so it is not an
1500
/// owned slice. An empty one has no storage and stays owned.
1501
@test unsafe fn testResolveSliceLiteralMutableTemporary() throws (testing::TestError) {
1502
    {
1503
        let mut a = testResolver();
1504
        let program = "let slice: *mut [i32] = &mut [1, 2, 3];";
1505
        let result = try resolveProgramStr(&mut a, program);
1506
        let err = try expectError(&result);
1507
        let case resolver::ErrorKind::TypeMismatch(_) = err.kind
1508
            else throw testing::TestError::Failed;
1509
    }
1510
    {
1511
        let mut a = testResolver();
1512
        let program = "fn f(items: &mut [i32]) {} fn g() { f(&mut [1, 2, 3]); }";
1513
        let result = try resolveProgramStr(&mut a, program);
1514
        try expectNoErrors(&result);
1515
    }
1516
    {
1517
        let mut a = testResolver();
1518
        let program = "let slice: *mut [i32] = &mut [];";
1519
        let result = try resolveProgramStr(&mut a, program);
1520
        try expectNoErrors(&result);
1521
    }
1522
}
1523
1524
@test unsafe fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
1525
    let mut a = testResolver();
1526
    let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
1527
    let result = try resolveProgramStr(&mut a, program);
1528
    let err = try expectError(&result);
1529
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1530
}
1531
1532
@test unsafe fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
1533
    let mut a = testResolver();
1534
    let program =
1535
        "static x: i32 = 0; unsafe { let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr; }";
1536
    let result = try resolveProgramStr(&mut a, program);
1537
    try expectNoErrors(&result);
1538
}
1539
1540
@test unsafe fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
1541
    {
1542
        let mut a = testResolver();
1543
        let program = "let x: i32 = 0; let ptr = &mut x;";
1544
        let result = try resolveProgramStr(&mut a, program);
1545
        try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1546
    }
1547
    {
1548
        let mut a = testResolver();
1549
        let program = "let mut x: i32 = 0; &mut x;";
1550
        let result = try resolveProgramStr(&mut a, program);
1551
        try expectNoErrors(&result);
1552
    }
1553
}
1554
1555
@test unsafe fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
1556
    {
1557
        let mut a = testResolver();
1558
        let program = "let xs: [i32; 3] = [1, 2, 3]; let slice = &mut xs[..];";
1559
        let result = try resolveProgramStr(&mut a, program);
1560
        try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
1561
    }
1562
    {
1563
        let mut a = testResolver();
1564
        let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
1565
        let result = try resolveProgramStr(&mut a, program);
1566
        try expectNoErrors(&result);
1567
    }
1568
}
1569
1570
@test unsafe fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
1571
    let mut a = testResolver();
1572
    let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
1573
    let result = try resolveProgramStr(&mut a, program);
1574
    let err = try expectError(&result);
1575
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
1576
}
1577
1578
@test unsafe fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
1579
    let mut a = testResolver();
1580
    let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
1581
    let result = try resolveProgramStr(&mut a, program);
1582
    try expectErrorKind(&result, resolver::ErrorKind::SliceRequiresAddress);
1583
}
1584
1585
@test unsafe fn testResolveSliceResliceRequiresAddressOf() throws (testing::TestError) {
1586
    let mut a = testResolver();
1587
    let program = "fn f(s: *[u8]) -> *[u8] { return s[..]; }";
1588
    let result = try resolveProgramStr(&mut a, program);
1589
    try expectErrorKind(&result, resolver::ErrorKind::SliceRequiresAddress);
1590
}
1591
1592
@test unsafe fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
1593
    {
1594
        let mut a = testResolver();
1595
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[..3];";
1596
        let result = try resolveProgramStr(&mut a, program);
1597
        try expectErrorKind(&result, resolver::ErrorKind::SliceRangeOutOfBounds);
1598
    }
1599
    {
1600
        let mut a = testResolver();
1601
        let program = "let xs: [u8; 2] = [1, 2]; let slice = &xs[3..];";
1602
        let result = try resolveProgramStr(&mut a, program);
1603
        try expectErrorKind(&result, resolver::ErrorKind::SliceRangeOutOfBounds);
1604
    }
1605
    {
1606
        let mut a = testResolver();
1607
        let program = "let xs: [u8; 4] = [1, 2, 3, 4]; let slice = &xs[3..2];";
1608
        let result = try resolveProgramStr(&mut a, program);
1609
        try expectErrorKind(&result, resolver::ErrorKind::SliceRangeOutOfBounds);
1610
    }
1611
}
1612
1613
@test unsafe fn testResolveArrayLenConstValue() throws (testing::TestError) {
1614
    let mut a = testResolver();
1615
    let program = "let xs: [i32; 3] = [1, 2, 3]; constant LEN: u32 = xs.len;";
1616
    let result = try resolveBlockStr(&mut a, program);
1617
    try expectNoErrors(&result);
1618
1619
    let constStmt = try getBlockStmt(result.root, 1);
1620
    let case ast::NodeValue::ConstDecl(decl) = constStmt.value
1621
        else throw testing::TestError::Failed;
1622
    let valueConst = resolver::constValueEntry(&a, decl.value)
1623
        else throw testing::TestError::Failed;
1624
    let case resolver::ConstValue::Int(lenVal) = valueConst else throw testing::TestError::Failed;
1625
    try testing::expect(lenVal.magnitude == 3);
1626
    try testing::expect(not lenVal.negative);
1627
}
1628
1629
@test unsafe fn testResolveIndexNonIndexable() throws (testing::TestError) {
1630
    let mut a = testResolver();
1631
    let program = "let flag: bool = true; flag[0];";
1632
    let result = try resolveProgramStr(&mut a, program);
1633
    try expectErrorKind(&result, resolver::ErrorKind::Bracket(resolver::BracketError::Base));
1634
}
1635
1636
/// Check that a bracket list on an array requires one index or range.
1637
@test unsafe fn testResolveSubscriptArity() throws (testing::TestError) {
1638
    let programs = [
1639
        @embed("lang/resolver/tests/fixtures/subscript/empty.rad"),
1640
        @embed("lang/resolver/tests/fixtures/subscript/range_and_index.rad"),
1641
        @embed("lang/resolver/tests/fixtures/subscript/store_two_indices.rad"),
1642
    ];
1643
    for program in programs {
1644
        let mut a = testResolver();
1645
        let result = try resolveProgramStr(&mut a, program);
1646
        try expectErrorKind(&result, resolver::ErrorKind::Bracket(
1647
            resolver::BracketError::Arity
1648
        ));
1649
    }
1650
}
1651
1652
/// Check that type and region operands do not supply index or range values.
1653
@test unsafe fn testResolveBracketExpectedValue() throws (testing::TestError) {
1654
    for program in [
1655
        @embed("lang/resolver/tests/fixtures/subscript/type_index.rad"),
1656
        @embed("lang/resolver/tests/fixtures/subscript/type_in_index.rad"),
1657
        @embed("lang/resolver/tests/fixtures/subscript/type_range.rad"),
1658
        @embed("lang/resolver/tests/fixtures/subscript/region_index.rad"),
1659
    ] {
1660
        let mut a = testResolver();
1661
        let result = try resolveProgramStr(&mut a, program);
1662
        try expectErrorKind(&result, resolver::ErrorKind::Bracket(
1663
            resolver::BracketError::ExpectedValue
1664
        ));
1665
    }
1666
}
1667
1668
/// Check that a record constructor with unresolved type arguments reports an error.
1669
@test unsafe fn testResolveUnresolvedRecordApplication() throws (testing::TestError) {
1670
    let mut a = testResolver();
1671
    let result = try resolveProgramStr(&mut a, "record R { x: u32 } R[u32] { x: 3 };");
1672
    try expectErrorKind(&result, resolver::ErrorKind::Bracket(resolver::BracketError::Generic));
1673
}
1674
1675
@test unsafe fn testResolveSliceFieldUnknown() throws (testing::TestError) {
1676
    let mut a = testResolver();
1677
    let program = "let xs: [i32; 2] = [1, 2]; (&xs[0..]).unknown;";
1678
    let result = try resolveProgramStr(&mut a, program);
1679
    try expectErrorKind(&result, resolver::ErrorKind::SliceFieldUnknown("unknown"));
1680
}
1681
1682
@test unsafe fn testResolveArrayFieldUnknown() throws (testing::TestError) {
1683
    let mut a = testResolver();
1684
    let program = "let xs: [i32; 2] = [1, 2]; xs.field;";
1685
    let result = try resolveProgramStr(&mut a, program);
1686
    try expectErrorKind(&result, resolver::ErrorKind::ArrayFieldUnknown("field"));
1687
}
1688
1689
@test unsafe fn testResolveIfConditionRequiresBool() throws (testing::TestError) {
1690
    {
1691
        let mut a = testResolver();
1692
        let result = try resolveProgramStr(&mut a, "if 42 {}");
1693
        let err = try expectError(&result);
1694
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
1695
    }
1696
    {
1697
        let mut a = testResolver();
1698
        let result = try resolveProgramStr(&mut a, "if true {}");
1699
        try expectNoErrors(&result);
1700
    }
1701
}
1702
1703
@test unsafe fn testResolveIfLetScopeBinding() throws (testing::TestError) {
1704
    let mut a = testResolver();
1705
    let result = try resolveProgramStr(&mut a, "let opt: ?i32 = 42; if let x = opt { x }");
1706
    try expectNoErrors(&result);
1707
1708
    // Get the if-let statement and verify `x` has type `i32`.
1709
    let ifLetStmt = try parser::tests::getBlockLastStmt(result.root);
1710
    let case ast::NodeValue::IfLet(ifLet) = ifLetStmt.value else throw testing::TestError::Failed;
1711
1712
    let thenStmt = try parser::tests::getBlockLastStmt(ifLet.thenBranch);
1713
    let case ast::NodeValue::ExprStmt(xExpr) = thenStmt.value else throw testing::TestError::Failed;
1714
1715
    try expectType(&a, xExpr, resolver::Type::I32);
1716
1717
    let scope = resolver::scopeFor(&a, ifLetStmt) else throw testing::TestError::Failed;
1718
    let xSym = resolver::findSymbolInScope(&a, scope, "x") else throw testing::TestError::Failed;
1719
    let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*xSym].data
1720
        else throw testing::TestError::Failed;
1721
1722
    try testing::expect(valType == resolver::Type::I32);
1723
}
1724
1725
@test unsafe fn testResolveIfLetScopeBindingError() throws (testing::TestError) {
1726
    let mut a = testResolver();
1727
    let result = try resolveProgramStr(
1728
        &mut a, "let opt: ?i32 = 42; if let x = opt { x } else { x }"
1729
    );
1730
    let err = try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("x"));
1731
1732
    // Verify the error comes from the else branch (offset 48).
1733
    let errNode = err.node else throw testing::TestError::Failed;
1734
    try testing::expect(errNode.span.offset == 48);
1735
}
1736
1737
/// Tests that `if let` with a condition expression binds the variable in scope.
1738
@test unsafe fn testResolveIfLetConditionBindsVariable() throws (testing::TestError) {
1739
    let mut a = testResolver();
1740
    let program = "let opt: ?i32 = 42; if let x = opt; x == 1 { x }";
1741
    let result = try resolveProgramStr(&mut a, program);
1742
    try expectNoErrors(&result);
1743
}
1744
1745
@test unsafe fn testResolveWhileConditionRequiresBool() throws (testing::TestError) {
1746
    {
1747
        let mut a = testResolver();
1748
        let result = try resolveProgramStr(&mut a, "while 1 {}");
1749
        let err = try expectError(&result);
1750
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
1751
    }
1752
    {
1753
        let mut a = testResolver();
1754
        let result = try resolveProgramStr(&mut a, "while true {}");
1755
        try expectNoErrors(&result);
1756
    }
1757
}
1758
1759
@test unsafe fn testResolveWhileLetBindingScope() throws (testing::TestError) {
1760
    {
1761
        let mut a = testResolver();
1762
        let program = "let mut opt: ?i32 = 42; while let x = opt; x > 0 { x; opt; }";
1763
        let result = try resolveProgramStr(&mut a, program);
1764
        try expectNoErrors(&result);
1765
1766
        let whileStmt = try parser::tests::getBlockLastStmt(result.root);
1767
        let case ast::NodeValue::WhileLet(loopNode) = whileStmt.value
1768
            else throw testing::TestError::Failed;
1769
1770
        let bodyStmt = try parser::tests::getBlockFirstStmt(loopNode.body);
1771
        try expectExprStmtType(&a, bodyStmt, resolver::Type::I32);
1772
1773
        let scope = resolver::scopeFor(&a, whileStmt) else throw testing::TestError::Failed;
1774
        let xSym = resolver::findSymbolInScope(&a, scope, "x")
1775
            else throw testing::TestError::Failed;
1776
        let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*xSym].data
1777
            else throw testing::TestError::Failed;
1778
        try testing::expect(valType == resolver::Type::I32);
1779
    }
1780
    {
1781
        let mut a = testResolver();
1782
        let program = "let opt: ?i32 = nil; while let x = opt; true { break } else { x }";
1783
        let result = try resolveProgramStr(&mut a, program);
1784
        try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("x"));
1785
    }
1786
}
1787
1788
@test unsafe fn testResolveForArrayBindsElementType() throws (testing::TestError) {
1789
    let mut a = testResolver();
1790
    let program = "let xs: [i32; 2] = [1, 2]; for x in xs { x; }";
1791
    let result = try resolveProgramStr(&mut a, program);
1792
    try expectNoErrors(&result);
1793
1794
    let forStmt = try parser::tests::getBlockLastStmt(result.root);
1795
    let case ast::NodeValue::For(loopNode) = forStmt.value else throw testing::TestError::Failed;
1796
1797
    let scope = resolver::scopeFor(&a, forStmt) else throw testing::TestError::Failed;
1798
    let sym = resolver::findSymbolInScope(&a, scope, "x") else throw testing::TestError::Failed;
1799
    let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*sym].data
1800
        else throw testing::TestError::Failed;
1801
    try testing::expect(valType == resolver::Type::I32);
1802
1803
    let bindingTy = resolver::typeFor(&a, loopNode.binding) else throw testing::TestError::Failed;
1804
    try testing::expect(bindingTy == resolver::Type::I32);
1805
}
1806
1807
@test unsafe fn testResolveForIndexedLoopBindsIndex() throws (testing::TestError) {
1808
    let mut a = testResolver();
1809
    let program = "let xs: [bool; 3] = [true; 3]; for value, idx in xs { value; idx; }";
1810
    let result = try resolveProgramStr(&mut a, program);
1811
    try expectNoErrors(&result);
1812
1813
    let forStmt = try parser::tests::getBlockLastStmt(result.root);
1814
    let case ast::NodeValue::For(loopNode) = forStmt.value else throw testing::TestError::Failed;
1815
1816
    let scope = resolver::scopeFor(&a, forStmt) else throw testing::TestError::Failed;
1817
    let valueSym = resolver::findSymbolInScope(&a, scope, "value")
1818
        else throw testing::TestError::Failed;
1819
    let case resolver::SymbolData::Value { type: valueValType, .. } = a.symbols[*valueSym].data
1820
        else throw testing::TestError::Failed;
1821
    try testing::expect(valueValType == resolver::Type::Bool);
1822
    let indexSym = resolver::findSymbolInScope(&a, scope, "idx")
1823
        else throw testing::TestError::Failed;
1824
    let case resolver::SymbolData::Value { type: indexValType, .. } = a.symbols[*indexSym].data
1825
        else throw testing::TestError::Failed;
1826
    try testing::expect(indexValType == resolver::Type::U32);
1827
1828
    let indexNode = loopNode.index else throw testing::TestError::Failed;
1829
    let indexTy = resolver::typeFor(&a, indexNode) else throw testing::TestError::Failed;
1830
    try testing::expect(indexTy == resolver::Type::U32);
1831
}
1832
1833
@test unsafe fn testResolveForSliceIterable() throws (testing::TestError) {
1834
    let mut a = testResolver();
1835
    let program = "let xs: [i32; 3] = [1, 2, 3]; for x in &xs[..] { x; }";
1836
    let result = try resolveProgramStr(&mut a, program);
1837
    try expectNoErrors(&result);
1838
1839
    let forStmt = try parser::tests::getBlockLastStmt(result.root);
1840
    let case ast::NodeValue::For(loopNode) = forStmt.value else throw testing::TestError::Failed;
1841
1842
    let bindingTy = resolver::typeFor(&a, loopNode.binding) else throw testing::TestError::Failed;
1843
    try testing::expect(bindingTy == resolver::Type::I32);
1844
}
1845
1846
@test unsafe fn testResolveForRequiresIterable() throws (testing::TestError) {
1847
    let mut a = testResolver();
1848
    let result = try resolveProgramStr(&mut a, "for x in true { x; }");
1849
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedIterable);
1850
}
1851
1852
@test unsafe fn testResolveForRangeBoundsMustNumeric() throws (testing::TestError) {
1853
    let mut a = testResolver();
1854
    let result = try resolveBlockStr(&mut a, "for i in 0..true { i; }");
1855
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
1856
}
1857
1858
@test unsafe fn testResolveMatchPatternTypeMismatch() throws (testing::TestError) {
1859
    let mut a = testResolver();
1860
    let program = "let val: i32 = 0; match val { case true => {} }";
1861
    let result = try resolveProgramStr(&mut a, program);
1862
    let err = try expectError(&result);
1863
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Bool);
1864
}
1865
1866
@test unsafe fn testResolveMatchUnionVariantTypeMismatch() throws (testing::TestError) {
1867
    let mut a = testResolver();
1868
    let program =
1869
        "union First { A }  union Second { B } fn run(val: First) { match val { case Second::B => {} } }";
1870
    let result = try resolveProgramStr(&mut a, program);
1871
    let err = try expectError(&result);
1872
1873
    let firstTy = try getTypeInScopeOf(&a, result.root, "First");
1874
    let secondTy = try getTypeInScopeOf(&a, result.root, "Second");
1875
    try expectTypeMismatch(err, resolver::Type::Nominal(firstTy), resolver::Type::Nominal(
1876
        secondTy
1877
    ));
1878
}
1879
1880
@test unsafe fn testResolveMatchUnionPayloadMissing() throws (testing::TestError) {
1881
    let mut a = testResolver();
1882
    let program = "union Opt { Some(i32) } fn run(val: Opt) { match val { case Opt::Some => {} } }";
1883
    let result = try resolveProgramStr(&mut a, program);
1884
    try expectErrorKind(&result, resolver::ErrorKind::UnionVariantPayloadMissing("Some"));
1885
}
1886
1887
@test unsafe fn testResolveMatchUnionVoidVariantExplicitDiscriminant() throws (testing::TestError) {
1888
    let mut a = testResolver();
1889
    let program = "union Opt { Some = 5 } fn run(val: Opt) { match val { case Opt::Some => {} } }";
1890
    let result = try resolveProgramStr(&mut a, program);
1891
    try expectNoErrors(&result);
1892
}
1893
1894
@test unsafe fn testResolveMatchUnionPayloadUnexpected() throws (testing::TestError) {
1895
    let mut a = testResolver();
1896
    let program = "union Opt { None } fn run(val: Opt) { match val { case Opt::None(x) => {} } }";
1897
    let result = try resolveProgramStr(&mut a, program);
1898
    try expectErrorKind(&result, resolver::ErrorKind::UnionVariantPayloadUnexpected("None"));
1899
}
1900
1901
@test unsafe fn testResolveMatchUnionUnknownVariant() throws (testing::TestError) {
1902
    let mut a = testResolver();
1903
    let program =
1904
        "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Unknown => {} } }";
1905
    let result = try resolveProgramStr(&mut a, program);
1906
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("Unknown"));
1907
}
1908
1909
@test unsafe fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
1910
    {
1911
        let mut a = testResolver();
1912
        let program =
1913
            "union Opt { Some, None } fn run(value: Opt) { match value { case Opt::Some => {} } }";
1914
        let result = try resolveProgramStr(&mut a, program);
1915
        try expectErrorKind(&result, resolver::ErrorKind::UnionMatchNonExhaustive("None"));
1916
    }
1917
    {
1918
        let mut a = testResolver();
1919
        let program = "union Opt { Some, None } fn run(value: Opt) { match value { else => {} } }";
1920
        let result = try resolveProgramStr(&mut a, program);
1921
        try expectNoErrors(&result);
1922
    }
1923
}
1924
1925
@test unsafe fn testResolveMatchUnionNonExhaustiveExplicitDiscriminants()
1926
    throws (testing::TestError)
1927
{
1928
    let mut a = testResolver();
1929
    let program =
1930
        "union U { A = 3, B = 9 } fn run(value: U) { match value { case U::A => {}, case U::B => {} } }";
1931
    let result = try resolveProgramStr(&mut a, program);
1932
    try expectNoErrors(&result);
1933
}
1934
1935
@test unsafe fn testResolveMatchUnionBindingScope() throws (testing::TestError) {
1936
    let mut a = testResolver();
1937
    let program =
1938
        "union Opt { Some(i32), None } fn f(value: Opt) { match value { case Opt::Some(x) if x > 0 => { x; } else => {} } }";
1939
    let result = try resolveProgramStr(&mut a, program);
1940
    try expectNoErrors(&result);
1941
1942
    let fnBlock = try getFnBody(&a, result.root, "f");
1943
    try testing::expect(fnBlock.statements.len > 0);
1944
1945
    let matchNode = fnBlock.statements[0];
1946
    let case ast::NodeValue::Match(sw) = matchNode.value else throw testing::TestError::Failed;
1947
    let caseNode = sw.prongs[0];
1948
1949
    let scope = resolver::scopeFor(&a, caseNode) else throw testing::TestError::Failed;
1950
    let payloadSym = resolver::findSymbolInScope(&a, scope, "x")
1951
        else throw testing::TestError::Failed;
1952
    let case resolver::SymbolData::Value { type: payloadValType, .. } = a.symbols[*payloadSym].data
1953
        else throw testing::TestError::Failed;
1954
    try testing::expect(payloadValType == resolver::Type::I32);
1955
}
1956
1957
@test unsafe fn testResolveMatchUnionPatternNonUnionType() throws (testing::TestError) {
1958
    let mut a = testResolver();
1959
    let program = "union Opt { Some, None } fn f(value: Opt) { match value { case true => {} } }";
1960
    let result = try resolveProgramStr(&mut a, program);
1961
    let err = try expectError(&result);
1962
    let optionTy = try getTypeInScopeOf(&a, result.root, "Opt");
1963
    try expectTypeMismatch(err, resolver::Type::Nominal(optionTy), resolver::Type::Bool);
1964
}
1965
1966
@test unsafe fn testResolveMatchGuardForms() throws (testing::TestError) {
1967
    let mut a = testResolver();
1968
    let program = "fn first(value: i32) { match value { case _ if true => {}, else => {} } }";
1969
    let result = try resolveProgramStr(&mut a, program);
1970
    try expectNoErrors(&result);
1971
}
1972
1973
/// Test that a binding prong binds the subject to the identifier.
1974
@test unsafe fn testResolveMatchBindingProng() throws (testing::TestError) {
1975
    let mut a = testResolver();
1976
    let program = "fn f(value: i32) -> i32 { match value { x => return x } }";
1977
    let result = try resolveProgramStr(&mut a, program);
1978
    try expectNoErrors(&result);
1979
}
1980
1981
/// Test that a binding prong with guard can use the bound variable.
1982
@test unsafe fn testResolveMatchBindingProngGuard() throws (testing::TestError) {
1983
    let mut a = testResolver();
1984
    let program =
1985
        "fn f(value: i32) -> i32 { match value { x if x > 0 => return x, _ => return 0 } }";
1986
    let result = try resolveProgramStr(&mut a, program);
1987
    try expectNoErrors(&result);
1988
}
1989
1990
/// Test that a binding prong covers all union variants for exhaustiveness.
1991
@test unsafe fn testResolveMatchBindingProngExhaustive() throws (testing::TestError) {
1992
    let mut a = testResolver();
1993
    let program = "union U { A, B, C } fn f(u: U) -> i32 { match u { x => return 0 } }";
1994
    let result = try resolveProgramStr(&mut a, program);
1995
    try expectNoErrors(&result);
1996
}
1997
1998
/// Test that `case x =>` fails if `x` is not in scope, since bare identifiers
1999
/// in case patterns are values to compare against, not bindings.
2000
@test unsafe fn testResolveMatchCaseUndefinedIdent() throws (testing::TestError) {
2001
    let mut a = testResolver();
2002
    let program = "fn f(n: i32) -> i32 { match n { case x => return 0 } }";
2003
    let result = try resolveProgramStr(&mut a, program);
2004
    try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("x"));
2005
}
2006
2007
/// Test matching on optionals: exhaustiveness and type unwrapping.
2008
@test unsafe fn testResolveMatchOptional() throws (testing::TestError) {
2009
    {
2010
        // Exhaustive: binding + nil case.
2011
        let mut a = testResolver();
2012
        let program = "fn f(opt: ?i32) { match opt { v => {}, case nil => {} } }";
2013
        let result = try resolveProgramStr(&mut a, program);
2014
        try expectNoErrors(&result);
2015
    }
2016
    {
2017
        // Missing nil case.
2018
        let mut a = testResolver();
2019
        let program = "fn f(opt: ?i32) { match opt { v => {} } }";
2020
        let result = try resolveProgramStr(&mut a, program);
2021
        try expectErrorKind(&result, resolver::ErrorKind::OptionalMatchMissingNil);
2022
    }
2023
    {
2024
        // Missing value case.
2025
        let mut a = testResolver();
2026
        let program = "fn f(opt: ?i32) { match opt { case nil => {} } }";
2027
        let result = try resolveProgramStr(&mut a, program);
2028
        try expectErrorKind(&result, resolver::ErrorKind::OptionalMatchMissingValue);
2029
    }
2030
    {
2031
        // Else covers both cases.
2032
        let mut a = testResolver();
2033
        let program = "fn f(opt: ?i32) { match opt { else => {} } }";
2034
        let result = try resolveProgramStr(&mut a, program);
2035
        try expectNoErrors(&result);
2036
    }
2037
    {
2038
        // Binding unwraps the inner type.
2039
        let mut a = testResolver();
2040
        let program =
2041
            "fn f(opt: ?i32) -> i32 { match opt { v => return v + 1, case nil => return 0 } }";
2042
        let result = try resolveProgramStr(&mut a, program);
2043
        try expectNoErrors(&result);
2044
    }
2045
}
2046
2047
/// Test that match on non-union types requires exhaustiveness.
2048
@test unsafe fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
2049
    {
2050
        // Match on i32 without catch-all should error.
2051
        let mut a = testResolver();
2052
        let program = "fn f(x: i32) { match x { case 1 => {} } }";
2053
        let result = try resolveProgramStr(&mut a, program);
2054
        try expectErrorKind(&result, resolver::ErrorKind::MatchNonExhaustive);
2055
    }
2056
    {
2057
        // Match on i32 with else is fine.
2058
        let mut a = testResolver();
2059
        let program = "fn f(x: i32) { match x { case 1 => {}, else => {} } }";
2060
        let result = try resolveProgramStr(&mut a, program);
2061
        try expectNoErrors(&result);
2062
    }
2063
    {
2064
        // Match on i32 with binding catch-all is fine.
2065
        let mut a = testResolver();
2066
        let program = "fn f(x: i32) { match x { y => {} } }";
2067
        let result = try resolveProgramStr(&mut a, program);
2068
        try expectNoErrors(&result);
2069
    }
2070
    {
2071
        // Match on i32 with wildcard catch-all is fine.
2072
        let mut a = testResolver();
2073
        let program = "fn f(x: i32) { match x { case _ => {} } }";
2074
        let result = try resolveProgramStr(&mut a, program);
2075
        try expectNoErrors(&result);
2076
    }
2077
}
2078
2079
/// Test that match on bool requires both true and false cases.
2080
@test unsafe fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
2081
    {
2082
        // Match on bool with both cases is fine.
2083
        let mut a = testResolver();
2084
        let program = "fn f(x: bool) { match x { case true => {}, case false => {} } }";
2085
        let result = try resolveProgramStr(&mut a, program);
2086
        try expectNoErrors(&result);
2087
    }
2088
    {
2089
        // Match on bool missing true should error.
2090
        let mut a = testResolver();
2091
        let program = "fn f(x: bool) { match x { case false => {} } }";
2092
        let result = try resolveProgramStr(&mut a, program);
2093
        try expectErrorKind(&result, resolver::ErrorKind::BoolMatchMissing(true));
2094
    }
2095
    {
2096
        // Match on bool missing false should error.
2097
        let mut a = testResolver();
2098
        let program = "fn f(x: bool) { match x { case true => {} } }";
2099
        let result = try resolveProgramStr(&mut a, program);
2100
        try expectErrorKind(&result, resolver::ErrorKind::BoolMatchMissing(false));
2101
    }
2102
    {
2103
        // Match on bool with else is fine.
2104
        let mut a = testResolver();
2105
        let program = "fn f(x: bool) { match x { else => {} } }";
2106
        let result = try resolveProgramStr(&mut a, program);
2107
        try expectNoErrors(&result);
2108
    }
2109
    {
2110
        // Match on bool with binding catch-all is fine.
2111
        let mut a = testResolver();
2112
        let program = "fn f(x: bool) { match x { b => {} } }";
2113
        let result = try resolveProgramStr(&mut a, program);
2114
        try expectNoErrors(&result);
2115
    }
2116
}
2117
2118
@test unsafe fn testResolveBreakRequiresLoop() throws (testing::TestError) {
2119
    {
2120
        let mut a = testResolver();
2121
        let result = try resolveProgramStr(&mut a, "break;");
2122
        try expectErrorKind(&result, resolver::ErrorKind::InvalidLoopControl);
2123
    }
2124
    {
2125
        let mut a = testResolver();
2126
        let result = try resolveProgramStr(&mut a, "loop { break }");
2127
        try expectNoErrors(&result);
2128
    }
2129
}
2130
2131
@test unsafe fn testResolveContinueRequiresLoop() throws (testing::TestError) {
2132
    {
2133
        let mut a = testResolver();
2134
        let result = try resolveProgramStr(&mut a, "continue;");
2135
        try expectErrorKind(&result, resolver::ErrorKind::InvalidLoopControl);
2136
    }
2137
    {
2138
        let mut a = testResolver();
2139
        let result = try resolveProgramStr(&mut a, "while true { continue }");
2140
        try expectNoErrors(&result);
2141
    }
2142
}
2143
2144
@test unsafe fn testResolveFnTypeVoidNoParams() throws (testing::TestError) {
2145
    let mut a = testResolver();
2146
    let result = try resolveProgramStr(&mut a, "fn f() {} f();");
2147
    try expectNoErrors(&result);
2148
2149
    let blockNode = result.root;
2150
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2151
    let fnNode = try getBlockStmt(blockNode, 0);
2152
    let callStmt = try getBlockStmt(blockNode, 1);
2153
2154
    {
2155
        // Verify the function symbol captures an empty parameter list and void return.
2156
        let sym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2157
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2158
            a.symbols[*sym].data else throw testing::TestError::Failed;
2159
        try testing::expect(fnTy.paramTypes.len == 0);
2160
        try testing::expect(*fnTy.returnType == resolver::Type::Void);
2161
    }
2162
    {
2163
        // Checking that the type of the call matches the function return type.
2164
        let callExpr = try expectExprStmtType(&a, callStmt, resolver::Type::Void);
2165
2166
        let fnSym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2167
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2168
            a.symbols[*fnSym].data else throw testing::TestError::Failed;
2169
        try expectType(&a, callExpr, *fnTy.returnType);
2170
    }
2171
}
2172
2173
@test unsafe fn testResolveFnTypeReturnsValue() throws (testing::TestError) {
2174
    let mut a = testResolver();
2175
    let program = "fn f() -> i32 { return 1; } f();";
2176
    let result = try resolveProgramStr(&mut a, program);
2177
    try expectNoErrors(&result);
2178
2179
    let blockNode = result.root;
2180
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2181
    let fnNode = try getBlockStmt(blockNode, 0);
2182
    let callStmt = try getBlockStmt(blockNode, 1);
2183
2184
    {
2185
        // Function returns i32 with no parameters.
2186
        let sym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2187
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2188
            a.symbols[*sym].data else throw testing::TestError::Failed;
2189
        try testing::expect(fnTy.paramTypes.len == 0);
2190
        try testing::expect(*fnTy.returnType == resolver::Type::I32);
2191
    }
2192
    {
2193
        // Call expression should inherit the function's return type.
2194
        let callExpr = try expectExprStmtType(&a, callStmt, resolver::Type::I32);
2195
2196
        let fnSym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2197
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2198
            a.symbols[*fnSym].data else throw testing::TestError::Failed;
2199
        try expectType(&a, callExpr, *fnTy.returnType);
2200
    }
2201
}
2202
2203
@test unsafe fn testResolveFnTypeSingleParam() throws (testing::TestError) {
2204
    let mut a = testResolver();
2205
    let program = "fn f(x: i8) {} let x: i8 = 1; f(x);";
2206
    let result = try resolveProgramStr(&mut a, program);
2207
    try expectNoErrors(&result);
2208
2209
    let blockNode = result.root;
2210
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2211
    let fnNode = try getBlockStmt(blockNode, 0);
2212
    let callStmt = try getBlockStmt(blockNode, 2);
2213
2214
    {
2215
        // Single parameter propagates nominal type onto the symbol and parameter node.
2216
        let sym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2217
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2218
            a.symbols[*sym].data else throw testing::TestError::Failed;
2219
        try testing::expect(fnTy.paramTypes.len == 1);
2220
        try testing::expect(*fnTy.paramTypes[0] == resolver::Type::I8);
2221
        try testing::expect(*fnTy.returnType == resolver::Type::Void);
2222
2223
        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
2224
            else throw testing::TestError::Failed;
2225
        try testing::expect(fnDecl.sig.params.len == 1);
2226
2227
        let paramNode = fnDecl.sig.params[0];
2228
        try expectType(&a, paramNode, resolver::Type::I8);
2229
    }
2230
    {
2231
        // Call should resolve to void, matching the function's return type.
2232
        let callExpr = try expectExprStmtType(&a, callStmt, resolver::Type::Void);
2233
        let fnSym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2234
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2235
            a.symbols[*fnSym].data else throw testing::TestError::Failed;
2236
        try expectType(&a, callExpr, *fnTy.returnType);
2237
    }
2238
}
2239
2240
@test unsafe fn testResolveFnTypeMultipleParams() throws (testing::TestError) {
2241
    let mut a = testResolver();
2242
    let program = "fn f(x: i8, y: i32) {} let x: i8 = 1; let y: i32 = 2; f(x, y);";
2243
    let result = try resolveProgramStr(&mut a, program);
2244
    try expectNoErrors(&result);
2245
2246
    let blockNode = result.root;
2247
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2248
    let fnNode = try getBlockStmt(blockNode, 0);
2249
    let callStmt = try getBlockStmt(blockNode, 3);
2250
2251
    {
2252
        // Ensure multi-parameter signatures record both argument types.
2253
        let sym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2254
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2255
            a.symbols[*sym].data else throw testing::TestError::Failed;
2256
        try testing::expect(fnTy.paramTypes.len == 2);
2257
        try testing::expect(*fnTy.paramTypes[0] == resolver::Type::I8);
2258
        try testing::expect(*fnTy.paramTypes[1] == resolver::Type::I32);
2259
        try testing::expect(*fnTy.returnType == resolver::Type::Void);
2260
2261
        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
2262
            else throw testing::TestError::Failed;
2263
        try testing::expect(fnDecl.sig.params.len == 2);
2264
2265
        let firstParam = fnDecl.sig.params[0];
2266
        let secondParam = fnDecl.sig.params[1];
2267
        try expectType(&a, firstParam, resolver::Type::I8);
2268
        try expectType(&a, secondParam, resolver::Type::I32);
2269
    }
2270
    {
2271
        // Call expression should again mirror the function return type.
2272
        let callExpr = try expectExprStmtType(&a, callStmt, resolver::Type::Void);
2273
        let fnSym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2274
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2275
            a.symbols[*fnSym].data else throw testing::TestError::Failed;
2276
        try expectType(&a, callExpr, *fnTy.returnType);
2277
    }
2278
}
2279
2280
@test unsafe fn testResolveFnRecursiveCall() throws (testing::TestError) {
2281
    let mut a = testResolver();
2282
    let program = "fn flip(b: bool) -> bool { if b { return false; } return flip(false); }";
2283
    let result = try resolveProgramStr(&mut a, program);
2284
    try expectNoErrors(&result);
2285
2286
    let blockNode = result.root;
2287
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2288
    let fnNode = try getBlockStmt(blockNode, 0);
2289
2290
    {
2291
        // Function symbol should be visible for recursive calls within its own body.
2292
        let sym = resolver::symbolFor(&a, fnNode) else throw testing::TestError::Failed;
2293
        let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnTy), .. } =
2294
            a.symbols[*sym].data else throw testing::TestError::Failed;
2295
        try testing::expect(fnTy.paramTypes.len == 1);
2296
        try testing::expect(*fnTy.paramTypes[0] == resolver::Type::Bool);
2297
        try testing::expect(*fnTy.returnType == resolver::Type::Bool);
2298
    }
2299
}
2300
2301
@test unsafe fn testResolveFnCallMissingArgument() throws (testing::TestError) {
2302
    let mut a = testResolver();
2303
    let program = "fn f(x: i8) {} f();";
2304
    let result = try resolveProgramStr(&mut a, program);
2305
    // Expect an error when a required parameter is omitted.
2306
    try expectErrorKind(&result, resolver::ErrorKind::FnArgCountMismatch(resolver::CountMismatch {
2307
        expected: 1,
2308
        actual: 0,
2309
    }));
2310
}
2311
2312
@test unsafe fn testResolveFnCallExtraArgument() throws (testing::TestError) {
2313
    let mut a = testResolver();
2314
    let program = "fn f() {} f(1);";
2315
    let result = try resolveProgramStr(&mut a, program);
2316
    // Passing more arguments than declared should fail.
2317
    try expectErrorKind(&result, resolver::ErrorKind::FnArgCountMismatch(resolver::CountMismatch {
2318
        expected: 0,
2319
        actual: 1,
2320
    }));
2321
}
2322
2323
@test unsafe fn testResolveFnCallArgumentTypeMismatch() throws (testing::TestError) {
2324
    let mut a = testResolver();
2325
    let program = "fn f(x: i8) {} f(true);";
2326
    let result = try resolveProgramStr(&mut a, program);
2327
    let err = try expectError(&result);
2328
    // The argument type (bool) should not match the parameter type (i8).
2329
    try expectTypeMismatch(err, resolver::Type::I8, resolver::Type::Bool);
2330
}
2331
2332
@test unsafe fn testResolveFnReturnTypeMismatch() throws (testing::TestError) {
2333
    let mut a = testResolver();
2334
    let program = "fn f() -> i32 { return true; }";
2335
    let result = try resolveProgramStr(&mut a, program);
2336
    let err = try expectError(&result);
2337
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Bool);
2338
}
2339
2340
@test unsafe fn testResolveFnReturnVoid() throws (testing::TestError) {
2341
    {
2342
        let mut a = testResolver();
2343
        let result = try resolveProgramStr(&mut a, "fn f() { return; }");
2344
        try expectNoErrors(&result);
2345
    }
2346
    {
2347
        let mut a = testResolver();
2348
        let result = try resolveProgramStr(&mut a, "fn g() -> i32 { return; }");
2349
        let err = try expectError(&result);
2350
        try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Void);
2351
    }
2352
}
2353
2354
@test unsafe fn testResolveFnMissingReturn() throws (testing::TestError) {
2355
    {
2356
        let mut a = testResolver();
2357
        let result = try resolveProgramStr(&mut a, "fn f() -> i32 {}");
2358
        try expectErrorKind(&result, resolver::ErrorKind::FnMissingReturn);
2359
    }
2360
    {
2361
        let mut a = testResolver();
2362
        let program = "fn g(flag: bool) -> i32 { if flag { return 1; } 2; }";
2363
        let result = try resolveProgramStr(&mut a, program);
2364
        try expectErrorKind(&result, resolver::ErrorKind::FnMissingReturn);
2365
    }
2366
}
2367
2368
/// Never-returning functions require divergence on every path.
2369
@test unsafe fn testResolveNeverReturn() throws (testing::TestError) {
2370
    for program in &[
2371
        "fn stop() -> ! { panic; } fn f() -> i32 { stop(); }",
2372
        "fn stop() -> ! { panic; } fn f() -> ! { return stop(); }",
2373
        "fn f(callback: fn() -> !) -> ! { callback(); }",
2374
        "fn stop() -> ! { panic; } fn f() -> ! { let _ = stop(); }",
2375
        "fn stop() -> ! { panic; } fn f() -> i32 { let value: i32 = stop(); }",
2376
        "union Token: Once { Held(u32) } fn stop() -> ! { panic; } fn f(token: Token) -> ! { stop(); }",
2377
        "union Token: Once { Held(u32) } fn stop() -> ! { panic; } fn f(token: Token) -> ! { return stop(); }",
2378
        "union Token: Once { Held(u32) } fn stop() -> ! throws (i32) { throw 1; } fn f(token: Token) -> ! { try! stop(); }",
2379
        "fn f() -> ! { while true {} }",
2380
        "fn f(flag: bool) -> ! { if flag { panic; } else { while true {} } }",
2381
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! throws (i32) { try f(); }",
2382
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> i32 { try f() catch { return 2; }; }",
2383
    ] {
2384
        let mut a = testResolver();
2385
        let result = try resolveProgramStr(&mut a, program);
2386
        try expectNoErrors(&result);
2387
    }
2388
}
2389
2390
/// A never-returning signature rejects any normal completion path.
2391
@test unsafe fn testResolveNeverFallthrough() throws (testing::TestError) {
2392
    for program in &[
2393
        "fn f() -> ! {}",
2394
        "fn f(flag: bool) -> ! { if flag { panic; } }",
2395
        "fn f() -> ! { while true { break; } }",
2396
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch {}; }",
2397
        "fn f() -> ! throws (i32) { throw 1; } fn g() -> ! { try f() catch e as i32 {}; }",
2398
    ] {
2399
        let mut a = testResolver();
2400
        let result = try resolveProgramStr(&mut a, program);
2401
        try expectErrorKind(&result, resolver::ErrorKind::FnMissingReturn);
2402
    }
2403
}
2404
2405
/// No value, including undefined, can construct a never return value.
2406
@test unsafe fn testResolveNeverValue() throws (testing::TestError) {
2407
    for program in &[
2408
        "fn f() -> ! { return; }",
2409
        "fn f() -> ! { return 1; }",
2410
        "unsafe fn f() -> ! { return undefined; }",
2411
        "fn ordinary() {} fn f() { let callback: fn() -> ! = ordinary; }",
2412
    ] {
2413
        let mut a = testResolver();
2414
        let result = try resolveProgramStr(&mut a, program);
2415
        let error = try expectError(&result);
2416
    }
2417
}
2418
2419
/// Caught errors preserve the caller's exact-use ownership obligations.
2420
@test unsafe fn testResolveNeverCaughtOwnership() throws (testing::TestError) {
2421
    for program in &[
2422
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { try fail() catch {}; }",
2423
        "union Token: Once { Held(u32) } fn fail() -> ! throws (i32) { throw 1; } fn f(token: Token) { let absent = try? fail(); }",
2424
    ] {
2425
        let mut a = testResolver();
2426
        let result = try resolveProgramStr(&mut a, program);
2427
        let error = try expectError(&result);
2428
        let case resolver::ErrorKind::LinearNotConsumed(_) = error.kind
2429
            else throw testing::TestError::Failed;
2430
    }
2431
}
2432
2433
@test unsafe fn testResolveFnAllPathsReturn() throws (testing::TestError) {
2434
    let mut a = testResolver();
2435
    let program = "fn h(flag: bool) -> i32 { if flag { return 1; } else { return 2; } }";
2436
    let result = try resolveProgramStr(&mut a, program);
2437
    try expectNoErrors(&result);
2438
}
2439
2440
/// Test that match statements with returns in all branches don't require a
2441
/// return at the end of the function.
2442
@test unsafe fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
2443
    {
2444
        // Union match with all variants returning.
2445
        let mut a = testResolver();
2446
        let program =
2447
            "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => return 2 } }";
2448
        let result = try resolveProgramStr(&mut a, program);
2449
        try expectNoErrors(&result);
2450
    }
2451
    {
2452
        // Match with default case where all branches return.
2453
        let mut a = testResolver();
2454
        let program = "fn f(x: i32) -> i32 { match x { case 1 => return 1, else => return 0, } }";
2455
        let result = try resolveProgramStr(&mut a, program);
2456
        try expectNoErrors(&result);
2457
    }
2458
    {
2459
        // Match where not all branches return should error.
2460
        let mut a = testResolver();
2461
        let program =
2462
            "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => {} } }";
2463
        let result = try resolveProgramStr(&mut a, program);
2464
        try expectErrorKind(&result, resolver::ErrorKind::FnMissingReturn);
2465
    }
2466
}
2467
2468
@test unsafe fn testResolveAssign() throws (testing::TestError) {
2469
    {
2470
        let mut a = testResolver();
2471
        let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
2472
        try expectNoErrors(&result);
2473
    }
2474
    {
2475
        let mut a = testResolver();
2476
        let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
2477
        try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
2478
    }
2479
    {
2480
        let mut a = testResolver();
2481
        let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
2482
        let err = try expectError(&result);
2483
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
2484
    }
2485
    {
2486
        let mut a = testResolver();
2487
        let result = try resolveProgramStr(&mut a, "set x = 1;");
2488
        try expectErrorKind(&result, resolver::ErrorKind::UnresolvedSymbol("x"));
2489
    }
2490
    {
2491
        let mut a = testResolver();
2492
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
2493
        try expectNoErrors(&result);
2494
    }
2495
    {
2496
        let mut a = testResolver();
2497
        let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
2498
        try expectNoErrors(&result);
2499
    }
2500
}
2501
2502
@test unsafe fn testResolveAssignSubscript() throws (testing::TestError) {
2503
    {
2504
        let mut a = testResolver();
2505
        let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
2506
        let result = try resolveProgramStr(&mut a, program);
2507
        try expectNoErrors(&result);
2508
    }
2509
    {
2510
        let mut a = testResolver();
2511
        let program =
2512
            "static xs: [u8; 2] = [0, 1]; unsafe { let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1; }";
2513
        let result = try resolveProgramStr(&mut a, program);
2514
        try expectNoErrors(&result);
2515
    }
2516
    {
2517
        let mut a = testResolver();
2518
        let program =
2519
            "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
2520
        let result = try resolveProgramStr(&mut a, program);
2521
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
2522
    }
2523
    {
2524
        let mut a = testResolver();
2525
        let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
2526
        let result = try resolveProgramStr(&mut a, program);
2527
        try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
2528
    }
2529
    {
2530
        let mut a = testResolver();
2531
        let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
2532
        let result = try resolveProgramStr(&mut a, program);
2533
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
2534
    }
2535
}
2536
2537
@test unsafe fn testResolveAssignIntegerLits() throws (testing::TestError) {
2538
    try expectAnalyzeOk("let x: i8 = 127;");
2539
    try expectAnalyzeOk("let x: i8 = 0x7F;");
2540
    try expectAnalyzeOk("let x: i8 = -128;");
2541
    try expectAnalyzeOk("let x: u8 = 255;");
2542
    try expectAnalyzeOk("let x: u8 = 0b11111111;");
2543
    try expectAnalyzeOk("let x: i16 = 0x7FFF;");
2544
    try expectAnalyzeOk("let x: i16 = -32768;");
2545
    try expectAnalyzeOk("let x: u16 = 0xFFFF;");
2546
    try expectAnalyzeOk("let x: i32 = 2147483647;");
2547
    try expectAnalyzeOk("let x: i32 = -2147483648;");
2548
    try expectAnalyzeOk("let x: u32 = 0xFFFFFFFF;");
2549
    try expectAnalyzeOk("let x: i64 = 9223372036854775807;");
2550
    try expectAnalyzeOk("let x: i64 = -9223372036854775808;");
2551
2552
    try expectAnalyzeOk("constant LIMIT: u8 = 0xFF;");
2553
2554
    try expectIntMismatch("let x: i8 = 128;", resolver::Type::I8);
2555
    try expectIntMismatch("let x: i8 = -129;", resolver::Type::I8);
2556
    try expectIntMismatch("let x: i8 = 0x80;", resolver::Type::I8);
2557
    try expectIntMismatch("let x: i8 = 0b10000000;", resolver::Type::I8);
2558
    try expectIntMismatch("let x: u8 = 256;", resolver::Type::U8);
2559
    try expectIntMismatch("let x: u8 = -1;", resolver::Type::U8);
2560
    try expectIntMismatch("let x: u8 = 0b100000000;", resolver::Type::U8);
2561
    try expectIntMismatch("let x: i16 = 32768;", resolver::Type::I16);
2562
    try expectIntMismatch("let x: i16 = -32769;", resolver::Type::I16);
2563
    try expectIntMismatch("let x: u16 = 65536;", resolver::Type::U16);
2564
    try expectIntMismatch("let x: u16 = -1;", resolver::Type::U16);
2565
    try expectIntMismatch("let x: i32 = 2147483648;", resolver::Type::I32);
2566
    try expectIntMismatch("let x: i32 = -2147483649;", resolver::Type::I32);
2567
    try expectIntMismatch("let x: i32 = 0xFFFFFFFF;", resolver::Type::I32);
2568
    try expectIntMismatch("let x: u32 = -1;", resolver::Type::U32);
2569
    try expectIntMismatch("let x: u32 = 0x100000000;", resolver::Type::U32);
2570
    try expectIntMismatch("let x: i64 = 9223372036854775808;", resolver::Type::I64);
2571
    try expectIntMismatch("let x: i64 = -9223372036854775809;", resolver::Type::I64);
2572
    try expectIntMismatch("constant LIMIT: u8 = 512;", resolver::Type::U8);
2573
    try expectIntMismatch("constant LIMIT: u8 = -5;", resolver::Type::U8);
2574
}
2575
2576
@test unsafe fn testNilCoercions() throws (testing::TestError) {
2577
    {
2578
        let mut a = testResolver();
2579
        let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
2580
        try expectNoErrors(&result);
2581
    }
2582
    {
2583
        let mut a = testResolver();
2584
        let program = "fn g(opt: ?i32) {} fn f() { g(nil); }";
2585
        let result = try resolveProgramStr(&mut a, program);
2586
        try expectNoErrors(&result);
2587
    }
2588
    {
2589
        let mut a = testResolver();
2590
        let program = "fn make(flag: bool) -> ?i32 { if flag { return 1; } return nil; }";
2591
        let result = try resolveProgramStr(&mut a, program);
2592
        try expectNoErrors(&result);
2593
    }
2594
}
2595
2596
@test unsafe fn testOptionalComparedWithNil() throws (testing::TestError) {
2597
    let mut a = testResolver();
2598
    let program =
2599
        "let opt: ?i32 = nil; opt == nil; nil == opt; opt == 1; 1 == opt; opt == opt; nil == nil;";
2600
    let result = try resolveBlockStr(&mut a, program);
2601
    try expectNoErrors(&result);
2602
2603
    for i in 1 .. 7 {
2604
        let stmt = try getBlockStmt(result.root, i);
2605
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
2606
    }
2607
}
2608
2609
@test unsafe fn testResolveRecordLiteralAllFieldsSet() throws (testing::TestError) {
2610
    let mut a = testResolver();
2611
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, y: 2 };";
2612
    let result = try resolveProgramStr(&mut a, program);
2613
    try expectNoErrors(&result);
2614
}
2615
2616
@test unsafe fn testResolveRecordLiteralMissingField() throws (testing::TestError) {
2617
    let mut a = testResolver();
2618
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1 };";
2619
    let result = try resolveProgramStr(&mut a, program);
2620
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldMissing("y"));
2621
}
2622
2623
@test unsafe fn testResolveRecordLiteralFieldTypeMismatch() throws (testing::TestError) {
2624
    let mut a = testResolver();
2625
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: true, y: 2 };";
2626
    let result = try resolveProgramStr(&mut a, program);
2627
    let err = try expectError(&result);
2628
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Bool);
2629
2630
    let errNode = err.node else throw testing::TestError::Failed;
2631
    let case ast::NodeValue::Bool(_) = errNode.value else throw testing::TestError::Failed;
2632
}
2633
2634
@test unsafe fn testResolveRecordLiteralExtraField() throws (testing::TestError) {
2635
    let mut a = testResolver();
2636
    let program = "record Pt { x: i32, y: i32 } let p = Pt { x: 1, z: 3, y: 2 };";
2637
    let result = try resolveProgramStr(&mut a, program);
2638
    let err = try expectError(&result);
2639
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2640
        else throw testing::TestError::Failed;
2641
}
2642
2643
/// Test that anonymous record literals with labels can be passed to functions expecting named
2644
/// records.
2645
@test unsafe fn testResolveAnonRecordLabeledToNamedRecord() throws (testing::TestError) {
2646
    let mut a = testResolver();
2647
    let program =
2648
        "record Pt { x: i32, y: i32 } fn foo(p: Pt) -> i32 { return p.x; } foo({ x: 1, y: 2 });";
2649
    let result = try resolveProgramStr(&mut a, program);
2650
    try expectNoErrors(&result);
2651
}
2652
2653
/// An unknown anonymous record field reports its name.
2654
@test unsafe fn testResolveAnonRecordWrongFieldName() throws (testing::TestError) {
2655
    let mut a = testResolver();
2656
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, z: 2 });";
2657
    let result = try resolveProgramStr(&mut a, program);
2658
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldUnknown("z"));
2659
}
2660
2661
/// Test that anonymous record with wrong field type causes type mismatch.
2662
@test unsafe fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
2663
    let mut a = testResolver();
2664
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
2665
    let result = try resolveProgramStr(&mut a, program);
2666
    let err = try expectError(&result);
2667
    let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;
2668
}
2669
2670
/// Test that anonymous record with missing field causes a missing field error.
2671
@test unsafe fn testResolveAnonRecordMissingField() throws (testing::TestError) {
2672
    let mut a = testResolver();
2673
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
2674
    let result = try resolveProgramStr(&mut a, program);
2675
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldMissing("y"));
2676
}
2677
2678
/// Test that anonymous record with extra field causes a count mismatch error.
2679
@test unsafe fn testResolveAnonRecordExtraField() throws (testing::TestError) {
2680
    let mut a = testResolver();
2681
    let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1, y: 2, z: 3 });";
2682
    let result = try resolveProgramStr(&mut a, program);
2683
    let err = try expectError(&result);
2684
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2685
        else throw testing::TestError::Failed;
2686
}
2687
2688
/// Test that anonymous record fields can be coerced (e.g., i32 to optional).
2689
@test unsafe fn testResolveAnonRecordFieldCoercion() throws (testing::TestError) {
2690
    let mut a = testResolver();
2691
    let program = "record Opt { x: ?i32 } fn foo(p: Opt) {} foo({ x: 42 });";
2692
    let result = try resolveProgramStr(&mut a, program);
2693
    try expectNoErrors(&result);
2694
}
2695
2696
/// Test that arrays of anonymous records with labeled fields are allowed.
2697
@test unsafe fn testResolveAnonRecordArray() throws (testing::TestError) {
2698
    let mut a = testResolver();
2699
    let program =
2700
        "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4 }];";
2701
    let result = try resolveProgramStr(&mut a, program);
2702
    try expectNoErrors(&result);
2703
}
2704
2705
/// Test that arrays of anonymous records with extra fields cause count mismatch.
2706
@test unsafe fn testResolveAnonRecordArrayMismatch() throws (testing::TestError) {
2707
    let mut a = testResolver();
2708
    let program =
2709
        "record Pt { x: i32, y: i32 } constant ARR: [Pt; 2] = [{ x: 1, y: 2 }, { x: 3, y: 4, z: 5 }];";
2710
    let result = try resolveProgramStr(&mut a, program);
2711
    let err = try expectError(&result);
2712
    let case resolver::ErrorKind::RecordFieldCountMismatch(_) = err.kind
2713
        else throw testing::TestError::Failed;
2714
}
2715
2716
/// Test that unlabeled record declarations are analyzed correctly.
2717
@test unsafe fn testResolveUnlabeledRecordDecl() throws (testing::TestError) {
2718
    let mut a = testResolver();
2719
    let program = "record R(i32, bool);";
2720
    let result = try resolveProgramStr(&mut a, program);
2721
    try expectNoErrors(&result);
2722
2723
    // Verify the type symbol was created with labeled=false.
2724
    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
2725
    let case resolver::NominalType::Record(recordType) = a.nominals[*nominalTy]
2726
        else throw testing::TestError::Failed;
2727
    try testing::expect(not recordType.labeled);
2728
    try testing::expect(recordType.fields.len == 2);
2729
    try testing::expect(recordType.fields[0].name == nil);
2730
    try testing::expect(recordType.fields[1].name == nil);
2731
}
2732
2733
@test unsafe fn testResolveLabeledRecordDecl() throws (testing::TestError) {
2734
    let mut a = testResolver();
2735
    let program = "record R { x: i32, y: i32 }";
2736
    let result = try resolveProgramStr(&mut a, program);
2737
    try expectNoErrors(&result);
2738
2739
    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
2740
    let case resolver::NominalType::Record(recordType) = a.nominals[*nominalTy]
2741
        else throw testing::TestError::Failed;
2742
    try testing::expect(recordType.labeled);
2743
    try testing::expect(recordType.fields.len == 2);
2744
    try testing::expect(recordType.fields[0].name <> nil);
2745
    try testing::expect(recordType.fields[1].name <> nil);
2746
}
2747
2748
@test unsafe fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
2749
    let mut a = testResolver();
2750
    let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";
2751
    let result = try resolveProgramStr(&mut a, program);
2752
    try expectNoErrors(&result);
2753
2754
    let fieldStmt = try getBlockStmt(result.root, 2);
2755
    try expectExprStmtType(&a, fieldStmt, resolver::Type::U8);
2756
}
2757
2758
@test unsafe fn testResolveRecordFieldAccessUnknownField() throws (testing::TestError) {
2759
    let mut a = testResolver();
2760
    let program = "record Pt { x: i32 } let p = Pt { x: 1 }; p.y;";
2761
    let result = try resolveProgramStr(&mut a, program);
2762
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldUnknown("y"));
2763
}
2764
2765
@test unsafe fn testResolveRecordFieldAccessOnFunctionReturn() throws (testing::TestError) {
2766
    let mut a = testResolver();
2767
    let program =
2768
        "record Pt { x: i32, y: i32 } fn make() -> Pt { return Pt { x: 5, y: 10 }; } make().x;";
2769
    let result = try resolveProgramStr(&mut a, program);
2770
    try expectNoErrors(&result);
2771
2772
    let stmt = try getBlockStmt(result.root, 2);
2773
    try expectExprStmtType(&a, stmt, resolver::Type::I32);
2774
}
2775
2776
@test unsafe fn testResolveRecordFieldAccessChained() throws (testing::TestError) {
2777
    let mut a = testResolver();
2778
    let program =
2779
        "record C { value: i32 } record B { c: C } record A { b: B } let a = A { b: B { c: C { value: 100 } } }; a.b.c.value;";
2780
    let result = try resolveProgramStr(&mut a, program);
2781
    try expectNoErrors(&result);
2782
2783
    let stmt = try getBlockStmt(result.root, 4);
2784
    try expectExprStmtType(&a, stmt, resolver::Type::I32);
2785
}
2786
2787
@test unsafe fn testResolveRecordFieldAccessOnInteger() throws (testing::TestError) {
2788
    let mut a = testResolver();
2789
    let program = "let x: i32 = 42; x.field;";
2790
    let result = try resolveBlockStr(&mut a, program);
2791
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedRecord);
2792
}
2793
2794
@test unsafe fn testResolveRecordFieldAccessOnArray() throws (testing::TestError) {
2795
    let mut a = testResolver();
2796
    let program = "let arr: [i32; 3] = [1, 2, 3]; arr.field;";
2797
    let result = try resolveProgramStr(&mut a, program);
2798
    try expectErrorKind(&result, resolver::ErrorKind::ArrayFieldUnknown("field"));
2799
}
2800
2801
@test unsafe fn testResolveRecordFieldAccessOnBool() throws (testing::TestError) {
2802
    let mut a = testResolver();
2803
    let program = "let b: bool = true; b.field;";
2804
    let result = try resolveProgramStr(&mut a, program);
2805
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedRecord);
2806
}
2807
2808
@test unsafe fn testResolveRecordFieldAccessOnOptional() throws (testing::TestError) {
2809
    let mut a = testResolver();
2810
    let program = "record Pt { x: i32 } let opt: ?Pt = Pt { x: 5 }; opt.x;";
2811
    let result = try resolveProgramStr(&mut a, program);
2812
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedRecord);
2813
}
2814
2815
/// Records may reference themselves through pointers without causing resolution errors.
2816
@test unsafe fn testResolveRecordSelfReferentialPointer() throws (testing::TestError) {
2817
    let mut a = testResolver();
2818
    let program = "record A { next: *A }";
2819
    let result = try resolveProgramStr(&mut a, program);
2820
    try expectNoErrors(&result);
2821
}
2822
2823
/// Mutually recursive records should resolve without infinite loops.
2824
@test unsafe fn testResolveRecordMutuallyRecursive() throws (testing::TestError) {
2825
    let mut a = testResolver();
2826
    let program = "record A { b: *B } record B { a: *A }";
2827
    let result = try resolveProgramStr(&mut a, program);
2828
    try expectNoErrors(&result);
2829
}
2830
2831
/// Unions may reference themselves through pointers without causing resolution errors.
2832
@test unsafe fn testResolveUnionSelfReferentialPointerAllowed() throws (testing::TestError) {
2833
    let mut a = testResolver();
2834
    let program = "union List { Cons(*List), Nil }";
2835
    let result = try resolveProgramStr(&mut a, program);
2836
    try expectNoErrors(&result);
2837
}
2838
2839
/// Mutually recursive unions should resolve without infinite loops.
2840
@test unsafe fn testResolveUnionMutuallyRecursive() throws (testing::TestError) {
2841
    let mut a = testResolver();
2842
    let program = "union A { HasB(*B), None } union B { HasA(*A), None }";
2843
    let result = try resolveProgramStr(&mut a, program);
2844
    try expectNoErrors(&result);
2845
}
2846
2847
/// Unions with record payloads containing slice references to self should resolve.
2848
/// This matches the pattern in sexpr.rad: `List { tail: *[Expr] }`.
2849
@test unsafe fn testResolveUnionRecordPayloadWithSliceSelfRef() throws (testing::TestError) {
2850
    let mut a = testResolver();
2851
    let program = "union Expr { Null, List { head: *[u8], tail: *[Expr] } }";
2852
    let result = try resolveProgramStr(&mut a, program);
2853
    try expectNoErrors(&result);
2854
}
2855
2856
@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
2857
    {
2858
        let mut a = testResolver();
2859
        let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
2860
        try expectNoErrors(&result);
2861
    }
2862
    {
2863
        let mut a = testResolver();
2864
        let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
2865
        let result = try resolveProgramStr(&mut a, program);
2866
        try expectNoErrors(&result);
2867
    }
2868
    {
2869
        let mut a = testResolver();
2870
        let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
2871
        let result = try resolveProgramStr(&mut a, program);
2872
        try expectNoErrors(&result);
2873
    }
2874
    {
2875
        let mut a = testResolver();
2876
        let program = "unsafe fn fetch() -> i32 { return undefined; }";
2877
        let result = try resolveProgramStr(&mut a, program);
2878
        try expectNoErrors(&result);
2879
    }
2880
}
2881
2882
@test unsafe fn testResolveBlockVoid() throws (testing::TestError) {
2883
    let mut a = testResolver();
2884
    let result = try resolveProgramStr(&mut a, "{ 42; }");
2885
    try expectNoErrors(&result);
2886
2887
    let block = try getBlockStmt(result.root, 0);
2888
    try expectType(&a, block, resolver::Type::Void);
2889
}
2890
2891
@test unsafe fn testResolveBlockNever() throws (testing::TestError) {
2892
    let mut a = testResolver();
2893
    let result = try resolveProgramStr(&mut a, "{ panic; }");
2894
    try expectNoErrors(&result);
2895
2896
    let block = try getBlockStmt(result.root, 0);
2897
    try expectType(&a, block, resolver::Type::Never);
2898
}
2899
2900
@test unsafe fn testResolveIfAllBranchesNever() throws (testing::TestError) {
2901
    let mut a = testResolver();
2902
    let program = "if true { panic; } else { panic; }";
2903
    let result = try resolveProgramStr(&mut a, program);
2904
    try expectNoErrors(&result);
2905
2906
    let stmt = try getBlockStmt(result.root, 0);
2907
    try expectType(&a, stmt, resolver::Type::Never);
2908
}
2909
2910
@test unsafe fn testResolveIfMixedBranchesNotNever() throws (testing::TestError) {
2911
    let mut a = testResolver();
2912
    let program = "if true { panic; } else {}";
2913
    let result = try resolveProgramStr(&mut a, program);
2914
    try expectNoErrors(&result);
2915
2916
    let stmt = try getBlockStmt(result.root, 0);
2917
    try expectType(&a, stmt, resolver::Type::Void);
2918
}
2919
2920
@test unsafe fn testResolveLetElse() throws (testing::TestError) {
2921
    let mut a = testResolver();
2922
    let program = "let opt: ?i32 = 42; let value = opt else panic; value;";
2923
    let result = try resolveProgramStr(&mut a, program);
2924
    try expectNoErrors(&result);
2925
2926
    let blockNode = result.root;
2927
    let case ast::NodeValue::Module(block) = blockNode.value else throw testing::TestError::Failed;
2928
    let letElseNode = try getBlockStmt(blockNode, 1);
2929
    let valueStmt = try getBlockStmt(blockNode, 2);
2930
2931
    {
2932
        // Ensure the bound identifier receives the inner optional type.
2933
        let valueExpr = try expectExprStmtType(&a, valueStmt, resolver::Type::I32);
2934
2935
        let sym = resolver::symbolFor(&a, valueExpr) else throw testing::TestError::Failed;
2936
        let case resolver::SymbolData::Value { type: valType, .. } = a.symbols[*sym].data
2937
            else throw testing::TestError::Failed;
2938
        try testing::expect(valType == resolver::Type::I32);
2939
    }
2940
    // The let-else statement itself should be typed as void.
2941
    try expectType(&a, letElseNode, resolver::Type::Void);
2942
}
2943
2944
@test unsafe fn testResolveLetElseDefaultValue() throws (testing::TestError) {
2945
    let mut a = testResolver();
2946
    let program = "let opt: ?i32 = nil; let value = opt else 42; value;";
2947
    let result = try resolveProgramStr(&mut a, program);
2948
    try expectNoErrors(&result);
2949
}
2950
2951
@test unsafe fn testResolveLetElseRequiresDivergentElse() throws (testing::TestError) {
2952
    let mut a = testResolver();
2953
    let program = "let opt: ?i32 = nil; let value = opt else {}; value;";
2954
    let result = try resolveProgramStr(&mut a, program);
2955
    let err = try expectError(&result);
2956
    try expectTypeMismatch(err, resolver::Type::I32, resolver::Type::Void);
2957
}
2958
2959
@test unsafe fn testResolveLetElseRequiresOptional() throws (testing::TestError) {
2960
    let mut a = testResolver();
2961
    let program = "let x: i32 = 42; let value = x else panic;";
2962
    let result = try resolveProgramStr(&mut a, program);
2963
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedOptional);
2964
}
2965
2966
/// Test that `if let mut` produces a mutable binding.
2967
@test unsafe fn testResolveIfLetMut() throws (testing::TestError) {
2968
    let mut a = testResolver();
2969
    let program = "let opt: ?i32 = 42; if let mut v = opt { set v = v + 1; }";
2970
    let result = try resolveProgramStr(&mut a, program);
2971
    try expectNoErrors(&result);
2972
}
2973
2974
/// Test that `if let` (without mut) rejects assignment.
2975
@test unsafe fn testResolveIfLetImmutable() throws (testing::TestError) {
2976
    let mut a = testResolver();
2977
    let program = "let opt: ?i32 = 42; if let v = opt { set v = 1; }";
2978
    let result = try resolveProgramStr(&mut a, program);
2979
    let err = try expectError(&result);
2980
    try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
2981
}
2982
2983
/// Test that `let mut ... else` produces a mutable binding.
2984
@test unsafe fn testResolveLetMutElse() throws (testing::TestError) {
2985
    let mut a = testResolver();
2986
    let program = "let opt: ?i32 = 42; let mut v = opt else panic; set v = v + 1;";
2987
    let result = try resolveProgramStr(&mut a, program);
2988
    try expectNoErrors(&result);
2989
}
2990
2991
/// Test that `let ... else` (without mut) rejects assignment.
2992
@test unsafe fn testResolveLetElseImmutable() throws (testing::TestError) {
2993
    let mut a = testResolver();
2994
    let program = "let opt: ?i32 = 42; let v = opt else panic; set v = 1;";
2995
    let result = try resolveProgramStr(&mut a, program);
2996
    let err = try expectError(&result);
2997
    try expectErrorKind(&result, resolver::ErrorKind::ImmutableBinding);
2998
}
2999
3000
@test unsafe fn testResolveLetCaseElse() throws (testing::TestError) {
3001
    {
3002
        let mut a = testResolver();
3003
        let program = "let case _ = 1 else panic;";
3004
        let result = try resolveProgramStr(&mut a, program);
3005
        try expectNoErrors(&result);
3006
    }
3007
    {
3008
        let mut a = testResolver();
3009
        let program = "let case _ = true else false;";
3010
        let result = try resolveProgramStr(&mut a, program);
3011
        try expectNoErrors(&result);
3012
    }
3013
}
3014
3015
@test unsafe fn testResolveLetCaseElseRequiresDivergentElse() throws (testing::TestError) {
3016
    let mut a = testResolver();
3017
    let program = "let case _ = 1 else {};";
3018
    let result = try resolveProgramStr(&mut a, program);
3019
    let err = try expectError(&result);
3020
    try expectTypeMismatch(err, resolver::Type::Int, resolver::Type::Void);
3021
}
3022
3023
@test unsafe fn testResolveTryValidPropagation() throws (testing::TestError) {
3024
    let mut a = testResolver();
3025
    let program = "fn fallible() throws (i32) {} fn caller() throws (i32) { try fallible() }";
3026
    let result = try resolveProgramStr(&mut a, program);
3027
    try expectNoErrors(&result);
3028
}
3029
3030
@test unsafe fn testResolveTryRequiresThrowsClause() throws (testing::TestError) {
3031
    let mut a = testResolver();
3032
    let program = "fn fallible() throws (i32) {} fn caller() { try fallible() }";
3033
    let result = try resolveProgramStr(&mut a, program);
3034
    try expectErrorKind(&result, resolver::ErrorKind::TryRequiresThrows);
3035
}
3036
3037
@test unsafe fn testResolveTryIncompatibleError() throws (testing::TestError) {
3038
    let mut a = testResolver();
3039
    let program = "fn fallible() throws (i32) {} fn caller() throws (i8) { try fallible() }";
3040
    let result = try resolveProgramStr(&mut a, program);
3041
    try expectErrorKind(&result, resolver::ErrorKind::TryIncompatibleError);
3042
}
3043
3044
@test unsafe fn testResolveTryNonThrowing() throws (testing::TestError) {
3045
    let mut a = testResolver();
3046
    let program = "fn safe() {} fn caller() throws (i32) { try safe() }";
3047
    let result = try resolveProgramStr(&mut a, program);
3048
    try expectErrorKind(&result, resolver::ErrorKind::TryNonThrowing);
3049
}
3050
3051
@test unsafe fn testResolveTryCatchBlockMatchesResult() throws (testing::TestError) {
3052
    let mut a = testResolver();
3053
    let program =
3054
        "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 42; }; }";
3055
    let result = try resolveProgramStr(&mut a, program);
3056
    try expectNoErrors(&result);
3057
}
3058
3059
@test unsafe fn testResolveTryCatchBlockDiverges() throws (testing::TestError) {
3060
    let mut a = testResolver();
3061
    let program =
3062
        "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { return 7; }; }";
3063
    let result = try resolveProgramStr(&mut a, program);
3064
    try expectNoErrors(&result);
3065
}
3066
3067
@test unsafe fn testResolveTryCatchBlockMustDiverge() throws (testing::TestError) {
3068
    let mut a = testResolver();
3069
    let program =
3070
        "union Error { Fail } fn fallible() -> u32 throws (Error) { throw Error::Fail; return 0; } fn caller() -> u32 { return try fallible() catch { 7; }; }";
3071
    let result = try resolveProgramStr(&mut a, program);
3072
    let err = try expectError(&result);
3073
    try expectTypeMismatch(err, resolver::Type::U32, resolver::Type::Void);
3074
}
3075
3076
@test unsafe fn testResolveCallMissingTry() throws (testing::TestError) {
3077
    let mut a = testResolver();
3078
    let program = "fn fallible() throws (i32) {} fn caller() { fallible() }";
3079
    let result = try resolveProgramStr(&mut a, program);
3080
    try expectErrorKind(&result, resolver::ErrorKind::MissingTry);
3081
}
3082
3083
/// Test that `try?` converts errors to optionals without requiring caller to throw.
3084
@test unsafe fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
3085
    // `try?` should wrap the return type in optional and not require caller to throw.
3086
    {
3087
        let mut a = testResolver();
3088
        let program =
3089
            "record S {} fn fallible() -> *S throws (i32) { panic; } fn caller() -> ?*S { return try? fallible(); }";
3090
        let result = try resolveProgramStr(&mut a, program);
3091
        try expectNoErrors(&result);
3092
    }
3093
    // `try?` works in non-throwing function.
3094
    {
3095
        let mut a = testResolver();
3096
        let program =
3097
            "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> ?i32 { return try? fallible(); }";
3098
        let result = try resolveProgramStr(&mut a, program);
3099
        try expectNoErrors(&result);
3100
    }
3101
    // `try?` can be used in if-let patterns.
3102
    {
3103
        let mut a = testResolver();
3104
        let program =
3105
            "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> i32 { if let x = try? fallible() { return x; } return 0; }";
3106
        let result = try resolveProgramStr(&mut a, program);
3107
        try expectNoErrors(&result);
3108
    }
3109
}
3110
3111
@test unsafe fn testResolveThrowValid() throws (testing::TestError) {
3112
    let mut a = testResolver();
3113
    let program = "fn fail() throws (i32) { throw 1; }";
3114
    let result = try resolveProgramStr(&mut a, program);
3115
    try expectNoErrors(&result);
3116
}
3117
3118
@test unsafe fn testResolveThrowRequiresThrowsClause() throws (testing::TestError) {
3119
    let mut a = testResolver();
3120
    let program = "fn fail() { throw 1; }";
3121
    let result = try resolveProgramStr(&mut a, program);
3122
    try expectErrorKind(&result, resolver::ErrorKind::ThrowRequiresThrows);
3123
}
3124
3125
@test unsafe fn testResolveThrowIncompatibleError() throws (testing::TestError) {
3126
    let mut a = testResolver();
3127
    let program = "fn fail() throws (i32) { throw true; }";
3128
    let result = try resolveProgramStr(&mut a, program);
3129
    try expectErrorKind(&result, resolver::ErrorKind::ThrowIncompatibleError);
3130
}
3131
3132
// Binary operation tests //////////////////////////////////////////////////////
3133
3134
@test unsafe fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
3135
    {
3136
        let mut a = testResolver();
3137
        let result = try resolveExprStr(&mut a, "4 + 4");
3138
        try expectNoErrors(&result);
3139
        try expectType(&a, result.root, resolver::Type::Int);
3140
    }
3141
    {
3142
        let mut a = testResolver();
3143
        let result = try resolveExprStr(&mut a, "10 - 3");
3144
        try expectNoErrors(&result);
3145
        try expectType(&a, result.root, resolver::Type::Int);
3146
    }
3147
    {
3148
        let mut a = testResolver();
3149
        let result = try resolveExprStr(&mut a, "5 * 6");
3150
        try expectNoErrors(&result);
3151
        try expectType(&a, result.root, resolver::Type::Int);
3152
    }
3153
    {
3154
        let mut a = testResolver();
3155
        let result = try resolveExprStr(&mut a, "20 / 4");
3156
        try expectNoErrors(&result);
3157
        try expectType(&a, result.root, resolver::Type::Int);
3158
    }
3159
    {
3160
        let mut a = testResolver();
3161
        let result = try resolveExprStr(&mut a, "17 % 5");
3162
        try expectNoErrors(&result);
3163
        try expectType(&a, result.root, resolver::Type::Int);
3164
    }
3165
    {
3166
        let mut a = testResolver();
3167
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: i32 = 5; x + y;");
3168
        try expectNoErrors(&result);
3169
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3170
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3171
    }
3172
    {
3173
        let mut a = testResolver();
3174
        let result = try resolveExprStr(&mut a, "1 + (2 * 3) - 4");
3175
        try expectNoErrors(&result);
3176
        try expectType(&a, result.root, resolver::Type::Int);
3177
    }
3178
    {
3179
        let mut a = testResolver();
3180
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n * 2;");
3181
        try expectNoErrors(&result);
3182
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3183
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3184
    }
3185
    {
3186
        let mut a = testResolver();
3187
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 2 * n;");
3188
        try expectNoErrors(&result);
3189
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3190
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3191
    }
3192
    {
3193
        let mut a = testResolver();
3194
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n - 1;");
3195
        try expectNoErrors(&result);
3196
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3197
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3198
    }
3199
}
3200
3201
@test unsafe fn testResolveBinaryOpComparison() throws (testing::TestError) {
3202
    {
3203
        let mut a = testResolver();
3204
        let result = try resolveExprStr(&mut a, "5 == 5");
3205
        try expectNoErrors(&result);
3206
        try expectType(&a, result.root, resolver::Type::Bool);
3207
    }
3208
    {
3209
        let mut a = testResolver();
3210
        let result = try resolveExprStr(&mut a, "5 <> 10");
3211
        try expectNoErrors(&result);
3212
        try expectType(&a, result.root, resolver::Type::Bool);
3213
    }
3214
    {
3215
        let mut a = testResolver();
3216
        let result = try resolveExprStr(&mut a, "5 < 10");
3217
        try expectNoErrors(&result);
3218
        try expectType(&a, result.root, resolver::Type::Bool);
3219
    }
3220
    {
3221
        let mut a = testResolver();
3222
        let result = try resolveExprStr(&mut a, "10 > 5");
3223
        try expectNoErrors(&result);
3224
        try expectType(&a, result.root, resolver::Type::Bool);
3225
    }
3226
    {
3227
        let mut a = testResolver();
3228
        let result = try resolveExprStr(&mut a, "5 <= 5");
3229
        try expectNoErrors(&result);
3230
        try expectType(&a, result.root, resolver::Type::Bool);
3231
    }
3232
    {
3233
        let mut a = testResolver();
3234
        let result = try resolveExprStr(&mut a, "10 >= 5");
3235
        try expectNoErrors(&result);
3236
        try expectType(&a, result.root, resolver::Type::Bool);
3237
    }
3238
    {
3239
        let mut a = testResolver();
3240
        let result = try resolveExprStr(&mut a, "true == false");
3241
        try expectNoErrors(&result);
3242
        try expectType(&a, result.root, resolver::Type::Bool);
3243
    }
3244
    {
3245
        let mut a = testResolver();
3246
        let result = try resolveExprStr(&mut a, "5 + 3 > 10 - 4");
3247
        try expectNoErrors(&result);
3248
        try expectType(&a, result.root, resolver::Type::Bool);
3249
    }
3250
    {
3251
        let mut a = testResolver();
3252
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n == 1;");
3253
        try expectNoErrors(&result);
3254
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3255
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
3256
    }
3257
    {
3258
        let mut a = testResolver();
3259
        let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 1 == n;");
3260
        try expectNoErrors(&result);
3261
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3262
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
3263
    }
3264
}
3265
3266
@test unsafe fn testResolveBinaryOpLogical() throws (testing::TestError) {
3267
    {
3268
        let mut a = testResolver();
3269
        let result = try resolveBlockStr(
3270
            &mut a, "let x: bool = true; let y: bool = false; x and y;"
3271
        );
3272
        try expectNoErrors(&result);
3273
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3274
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
3275
    }
3276
    {
3277
        let mut a = testResolver();
3278
        let result = try resolveBlockStr(
3279
            &mut a, "let x: bool = true; let y: bool = false; x or y;"
3280
        );
3281
        try expectNoErrors(&result);
3282
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3283
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
3284
    }
3285
    {
3286
        let mut a = testResolver();
3287
        let result = try resolveExprStr(&mut a, "true and false");
3288
        try expectNoErrors(&result);
3289
        try expectType(&a, result.root, resolver::Type::Bool);
3290
    }
3291
}
3292
3293
@test unsafe fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
3294
    {
3295
        let mut a = testResolver();
3296
        let result = try resolveProgramStr(&mut a, "4 + true");
3297
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3298
    }
3299
    {
3300
        let mut a = testResolver();
3301
        let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: bool = false; x + y;");
3302
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3303
    }
3304
    {
3305
        let mut a = testResolver();
3306
        let result = try resolveProgramStr(&mut a, "10 - false");
3307
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3308
    }
3309
    {
3310
        let mut a = testResolver();
3311
        let result = try resolveProgramStr(&mut a, "5 * true");
3312
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3313
    }
3314
    {
3315
        let mut a = testResolver();
3316
        let result = try resolveProgramStr(&mut a, "20 / false");
3317
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3318
    }
3319
    {
3320
        let mut a = testResolver();
3321
        let result = try resolveProgramStr(&mut a, "17 % true");
3322
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3323
    }
3324
    {
3325
        let mut a = testResolver();
3326
        let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
3327
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3328
    }
3329
}
3330
3331
@test unsafe fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
3332
    {
3333
        let mut a = testResolver();
3334
        let result = try resolveProgramStr(&mut a, "42 and true");
3335
        let err = try expectError(&result);
3336
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
3337
    }
3338
    {
3339
        let mut a = testResolver();
3340
        let result = try resolveProgramStr(&mut a, "true or 5");
3341
        let err = try expectError(&result);
3342
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
3343
    }
3344
    {
3345
        let mut a = testResolver();
3346
        let result = try resolveProgramStr(&mut a, "1 and 2");
3347
        let err = try expectError(&result);
3348
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
3349
    }
3350
}
3351
3352
@test unsafe fn testResolveBinaryOpComparisonTypeMismatch() throws (testing::TestError) {
3353
    let mut a = testResolver();
3354
    let result = try resolveProgramStr(&mut a, "true < false");
3355
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3356
}
3357
3358
// Unary operation tests ///////////////////////////////////////////////////////
3359
3360
@test unsafe fn testResolveUnaryOpNot() throws (testing::TestError) {
3361
    {
3362
        let mut a = testResolver();
3363
        let result = try resolveExprStr(&mut a, "not true");
3364
        try expectNoErrors(&result);
3365
        try expectType(&a, result.root, resolver::Type::Bool);
3366
    }
3367
    {
3368
        let mut a = testResolver();
3369
        let result = try resolveBlockStr(&mut a, "let x: bool = true; not x;");
3370
        try expectNoErrors(&result);
3371
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3372
        try expectExprStmtType(&a, stmt, resolver::Type::Bool);
3373
    }
3374
    {
3375
        let mut a = testResolver();
3376
        let result = try resolveExprStr(&mut a, "not (true and false)");
3377
        try expectNoErrors(&result);
3378
        try expectType(&a, result.root, resolver::Type::Bool);
3379
    }
3380
    {
3381
        let mut a = testResolver();
3382
        let result = try resolveProgramStr(&mut a, "not 42");
3383
        let err = try expectError(&result);
3384
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::Int);
3385
    }
3386
    {
3387
        let mut a = testResolver();
3388
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; not x;");
3389
        let err = try expectError(&result);
3390
        try expectTypeMismatch(err, resolver::Type::Bool, resolver::Type::I32);
3391
    }
3392
}
3393
3394
@test unsafe fn testResolveUnaryOpNeg() throws (testing::TestError) {
3395
    {
3396
        let mut a = testResolver();
3397
        let result = try resolveExprStr(&mut a, "-42");
3398
        try expectNoErrors(&result);
3399
        try expectType(&a, result.root, resolver::Type::Int);
3400
    }
3401
    {
3402
        let mut a = testResolver();
3403
        let result = try resolveBlockStr(&mut a, "let x: i32 = 10; -x;");
3404
        try expectNoErrors(&result);
3405
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3406
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3407
    }
3408
    {
3409
        let mut a = testResolver();
3410
        let result = try resolveExprStr(&mut a, "-(5 + 3)");
3411
        try expectNoErrors(&result);
3412
        try expectType(&a, result.root, resolver::Type::Int);
3413
    }
3414
    {
3415
        let mut a = testResolver();
3416
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; -x;");
3417
        try expectNoErrors(&result);
3418
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3419
        try expectExprStmtType(&a, stmt, resolver::Type::I8);
3420
    }
3421
    {
3422
        let mut a = testResolver();
3423
        let result = try resolveProgramStr(&mut a, "-true");
3424
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3425
    }
3426
    {
3427
        let mut a = testResolver();
3428
        let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
3429
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3430
    }
3431
}
3432
3433
@test unsafe fn testResolveUnaryOpBitNot() throws (testing::TestError) {
3434
    {
3435
        let mut a = testResolver();
3436
        let result = try resolveExprStr(&mut a, "~42");
3437
        try expectNoErrors(&result);
3438
        try expectType(&a, result.root, resolver::Type::Int);
3439
    }
3440
    {
3441
        let mut a = testResolver();
3442
        let result = try resolveBlockStr(&mut a, "let x: u32 = 255; ~x;");
3443
        try expectNoErrors(&result);
3444
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3445
        try expectExprStmtType(&a, stmt, resolver::Type::U32);
3446
    }
3447
    {
3448
        let mut a = testResolver();
3449
        let result = try resolveExprStr(&mut a, "~(0xFF)");
3450
        try expectNoErrors(&result);
3451
        try expectType(&a, result.root, resolver::Type::Int);
3452
    }
3453
    {
3454
        let mut a = testResolver();
3455
        let result = try resolveBlockStr(&mut a, "let x: i8 = 5; ~x;");
3456
        try expectNoErrors(&result);
3457
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3458
        try expectExprStmtType(&a, stmt, resolver::Type::I8);
3459
    }
3460
    {
3461
        let mut a = testResolver();
3462
        let result = try resolveProgramStr(&mut a, "~true");
3463
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3464
    }
3465
    {
3466
        let mut a = testResolver();
3467
        let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
3468
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3469
    }
3470
}
3471
3472
@test unsafe fn testResolveUnaryOpNested() throws (testing::TestError) {
3473
    {
3474
        let mut a = testResolver();
3475
        let result = try resolveExprStr(&mut a, "not not true");
3476
        try expectNoErrors(&result);
3477
        try expectType(&a, result.root, resolver::Type::Bool);
3478
    }
3479
    {
3480
        let mut a = testResolver();
3481
        let result = try resolveExprStr(&mut a, "--42");
3482
        try expectNoErrors(&result);
3483
        try expectType(&a, result.root, resolver::Type::Int);
3484
    }
3485
    {
3486
        let mut a = testResolver();
3487
        let result = try resolveExprStr(&mut a, "~~0xFF");
3488
        try expectNoErrors(&result);
3489
        try expectType(&a, result.root, resolver::Type::Int);
3490
    }
3491
    {
3492
        let mut a = testResolver();
3493
        let result = try resolveExprStr(&mut a, "-(~42)");
3494
        try expectNoErrors(&result);
3495
        try expectType(&a, result.root, resolver::Type::Int);
3496
    }
3497
}
3498
3499
// test fn testNormalPointerArithmetic() throws (testing::TestError) {
3500
//     mut a = testResolver();
3501
//     let result = try resolveProgramStr(&mut a, "fn test() { let ptr: *i32 = undefined; let x =
3502
// ptr + 1; }");
3503
//     try expectNoErrors(&result);
3504
// }
3505
3506
// Dereference tests //////////////////////////////////////////////////////////
3507
3508
@test unsafe fn testResolveDeref() throws (testing::TestError) {
3509
    {
3510
        let mut a = testResolver();
3511
        let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
3512
        try expectNoErrors(&result);
3513
        let stmt = try parser::tests::getBlockLastStmt(result.root);
3514
        try expectExprStmtType(&a, stmt, resolver::Type::I32);
3515
    }
3516
    {
3517
        let mut a = testResolver();
3518
        let result = try resolveExprStr(&mut a, "*42");
3519
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedPointer);
3520
    }
3521
    {
3522
        let mut a = testResolver();
3523
        let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
3524
        try expectErrorKind(&result, resolver::ErrorKind::ExpectedPointer);
3525
    }
3526
}
3527
3528
@test unsafe fn testResolveAssignDeref() throws (testing::TestError) {
3529
    {
3530
        let mut a = testResolver();
3531
        let program = "static x: i32 = 0; unsafe { let ptr: *mut i32 = &mut x; set *ptr = 42; }";
3532
        let result = try resolveProgramStr(&mut a, program);
3533
        try expectNoErrors(&result);
3534
    }
3535
    {
3536
        let mut a = testResolver();
3537
        let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
3538
        let result = try resolveProgramStr(&mut a, program);
3539
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
3540
    }
3541
    {
3542
        let mut a = testResolver();
3543
        let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
3544
        let result = try resolveProgramStr(&mut a, program);
3545
        try expectErrorKind(&result, resolver::ErrorKind::ImmutablePointer);
3546
    }
3547
    {
3548
        let mut a = testResolver();
3549
        let program = "static x: u8 = 0; unsafe { let mut ptr: *mut u8 = &mut x; set *ptr = 255; }";
3550
        let result = try resolveProgramStr(&mut a, program);
3551
        try expectNoErrors(&result);
3552
    }
3553
}
3554
3555
// Type inference tests ///////////////////////////////////////////////////////
3556
3557
@test unsafe fn testResolveBasicTypeInference() throws (testing::TestError) {
3558
    {
3559
        // Boolean literals are unambiguous.
3560
        let mut a = testResolver();
3561
        let result = try resolveProgramStr(&mut a, "let x = true; x;");
3562
        try expectNoErrors(&result);
3563
3564
        let xStmt = try parser::tests::getBlockLastStmt(result.root);
3565
        try expectExprStmtType(&a, xStmt, resolver::Type::Bool);
3566
    }
3567
    {
3568
        // Integer literals are ambiguous.
3569
        let mut a = testResolver();
3570
        let result = try resolveProgramStr(&mut a, "let x = 34;");
3571
        try expectErrorKind(&result, resolver::ErrorKind::CannotInferType);
3572
    }
3573
}
3574
3575
/// Test-only imports do not require their modules in a normal build.
3576
@test unsafe fn testConditionalUse() throws (testing::TestError) {
3577
    let mut a = testResolver();
3578
    set a.config.buildTest = false;
3579
    let source = "@test use missing::testing; fn value() -> u32 { return 1; }";
3580
    let result = try resolveProgramStr(&mut a, source);
3581
    try expectNoErrors(&result);
3582
    set a.config.buildTest = true;
3583
    let enabled = try resolveProgramStr(&mut a, source);
3584
    try testing::expect(enabled.diagnostics.errors.len > 0);
3585
}
3586
3587
/// Named record literals distinguish unknown fields from field order errors.
3588
@test unsafe fn recordFieldDiagnostics() throws (testing::TestError) {
3589
    let mut a = testResolver();
3590
    let result = try resolveProgramStr(
3591
        &mut a, "record R: Copy { x: u32, y: u32 } fn f() -> R { return R { x: 1, z: 2 }; }"
3592
    );
3593
    try expectErrorKind(&result, resolver::ErrorKind::RecordFieldUnknown("z"));
3594
}
3595
3596
/// Exhaustion reports the byte requirements and keeps the arena unchanged.
3597
@test unsafe fn metadataExhaustion() throws (testing::TestError) {
3598
    static bytes: [u64; 8] = [0; 8];
3599
    let arena = heap::over(@sliceOf(&mut bytes[0] as *mut u8, 64));
3600
    let available = heap::remaining(arena);
3601
    assert available < @sizeOf(resolver::NodeData);
3602
    try resolver::nodeDataStorage(arena, 1) catch err {
3603
        assert err.required == @sizeOf(resolver::NodeData) as u64;
3604
        assert err.available == available;
3605
        assert heap::used(arena) == 0;
3606
        return;
3607
    };
3608
    throw testing::TestError::Failed;
3609
}
3610
3611
/// Overflow is checked before narrowing the byte count for the allocator.
3612
@test unsafe fn metadataOverflow() throws (testing::TestError) {
3613
    static bytes: [u64; 8] = [0; 8];
3614
    let arena = heap::over(@sliceOf(&mut bytes[0] as *mut u8, 64));
3615
    try resolver::nodeDataStorage(arena, 0xffffffff) catch err {
3616
        assert err.required == 0xffffffff * @sizeOf(resolver::NodeData) as u64;
3617
        assert heap::used(arena) == 0;
3618
        return;
3619
    };
3620
    throw testing::TestError::Failed;
3621
}
3622
3623
/// Empty and valid metadata requests have their exact requested length.
3624
@test unsafe fn metadataStorage() throws (testing::TestError) {
3625
    static words: [u64; 512] = [0; 512];
3626
    let arena = heap::over(@sliceOf(&mut words[0] as *mut u8, 4096));
3627
    let empty = try! resolver::nodeDataStorage(arena, 0);
3628
    assert empty.len == 0 and heap::used(arena) == 0;
3629
    let data = try! resolver::nodeDataStorage(arena, 2);
3630
    assert data.len == 2;
3631
    assert heap::used(arena) == 2 * @sizeOf(resolver::NodeData);
3632
}
3633
3634
/// Heap storage cannot be returned or copied as a runtime value.
3635
@test unsafe fn testConstantHeapValues() throws (testing::TestError) {
3636
    for body in [
3637
        "fn f() -> Heap { return POOL; }",
3638
        "static COPY: Heap = POOL;",
3639
        "constant COPY: Heap = POOL;",
3640
        "static OPTIONAL: ?Heap = new(64);",
3641
        "constant OPTIONAL: ?Heap = new(64);",
3642
    ] {
3643
        let mut a = testResolver();
3644
        let result = try resolveProgramStr(
3645
            &mut a,
3646
            program(
3647
                &[
3648
                    "@language record Heap {} ",
3649
                    "@intrinsic constant fn new(size: u32) -> Heap; ",
3650
                    "constant POOL: Heap = new(64); ", body,
3651
                ]
3652
            )
3653
        );
3654
        try expectErrorKind(&result, resolver::ErrorKind::HeapValue);
3655
    }
3656
}
3657
3658
/// Check that a generic body can transfer an abstract parameter and borrow it.
3659
@test unsafe fn testResolveGenericFunctionBody() throws (testing::TestError) {
3660
    for program in [
3661
        @embed("lang/resolver/tests/fixtures/generic_body/identity.rad"),
3662
        @embed("lang/resolver/tests/fixtures/generic_body/borrow.rad"),
3663
        @embed("lang/resolver/tests/fixtures/generic_body/region_binder.rad"),
3664
        @embed("lang/resolver/tests/fixtures/generic_body/callback.rad"),
3665
        @embed("lang/resolver/tests/fixtures/generic_body/copy.rad"),
3666
    ] {
3667
        let mut a = testResolver();
3668
        let result = try resolveProgramStr(&mut a, program);
3669
        try expectNoErrors(&result);
3670
    }
3671
}
3672
3673
/// Check an unused generic body for arithmetic on an abstract type.
3674
@test unsafe fn testResolveGenericFunctionOperators() throws (testing::TestError) {
3675
    let mut a = testResolver();
3676
    let result = try resolveProgramStr(
3677
        &mut a, "fn add[T](a: T, b: T) -> T { return a + b; }"
3678
    );
3679
    try expectErrorKind(&result, resolver::ErrorKind::ExpectedNumeric);
3680
}
3681
3682
/// Check that every path transfers an owned abstract parameter.
3683
@test unsafe fn testResolveGenericFunctionDiscard() throws (testing::TestError) {
3684
    let mut a = testResolver();
3685
    let result = try resolveProgramStr(
3686
        &mut a, "fn discard[T](value: T) {}"
3687
    );
3688
    try expectErrorKind(&result, resolver::ErrorKind::LinearNotConsumed("value"));
3689
}
3690
3691
/// Reject equality without a corresponding bound and a bare generic function.
3692
@test unsafe fn testResolveGenericInvalidOperations() throws (testing::TestError) {
3693
    let mut a = testResolver();
3694
    let equality = try resolveProgramStr(
3695
        &mut a, "fn equal[T: Copy](a: T, b: T) -> bool { return a == b; }"
3696
    );
3697
    try expectError(&equality);
3698
3699
    let mut b = testResolver();
3700
    let bare = try resolveProgramStr(
3701
        &mut b, "fn identity[T](x: T) -> T { return x; } fn hold() { let f = identity; }"
3702
    );
3703
    try expectErrorKind(&bare, resolver::ErrorKind::Bracket(
3704
        resolver::BracketError::MissingArguments
3705
    ));
3706
}
3707
3708
/// Reject a duplicated use or the escape of a borrowed abstract local.
3709
@test unsafe fn testResolveGenericBodyOwnership() throws (testing::TestError) {
3710
    let mut a = testResolver();
3711
    let duplicate = try resolveProgramStr(
3712
        &mut a, "fn duplicate[T](x: T) -> [T; 2] { return [x, x]; }"
3713
    );
3714
    try expectErrorKind(&duplicate, resolver::ErrorKind::LinearUseAfterConsume("x"));
3715
3716
    let mut b = testResolver();
3717
    let escape = try resolveProgramStr(
3718
        &mut b, "fn escape[T: Copy](x: &'r T, y: T) -> &'r T { return &y; }"
3719
    );
3720
    try expectError(&escape);
3721
}
3722
3723
/// Check signature substitution in both direct calls and function values.
3724
@test unsafe fn testResolveGenericFunctionApplication() throws (testing::TestError) {
3725
    for program in [
3726
        @embed("lang/resolver/tests/fixtures/generic_application/scalar.rad"),
3727
        @embed("lang/resolver/tests/fixtures/generic_application/function_value.rad"),
3728
        @embed("lang/resolver/tests/fixtures/generic_application/array.rad"),
3729
        @embed("lang/resolver/tests/fixtures/generic_application/optional.rad"),
3730
        @embed("lang/resolver/tests/fixtures/generic_application/forward.rad"),
3731
    ] {
3732
        let mut a = testResolver();
3733
        let result = try resolveProgramStr(&mut a, program);
3734
        try expectNoErrors(&result);
3735
    }
3736
}
3737
3738
/// Check lexical selection and reuse of ordered type applications.
3739
@test unsafe fn testResolveGenericFunctionApplicationIdentity() throws (testing::TestError) {
3740
    let mut a = testResolver();
3741
    let result = try resolveProgramStr(
3742
        &mut a,
3743
        "fn id[T](x: T) -> T { return x; } fn checks() { let a = id[u32](1); let b = id[u32](2); let c = id[bool](true); }"
3744
    );
3745
    try expectNoErrors(&result);
3746
    try testing::expect(a.typeTables.functionApplications.len == 2);
3747
3748
    let mut b = testResolver();
3749
    let shadowed = try resolveProgramStr(
3750
        &mut b,
3751
        "fn id[T](x: T) -> T { return x; } fn check() { let id: [u32; 2] = [1, 2]; let x = id[0]; }"
3752
    );
3753
    try expectNoErrors(&shadowed);
3754
    try testing::expect(b.typeTables.functionApplications.len == 0);
3755
}
3756
3757
/// Check Copy obligations at concrete and symbolic call sites.
3758
@test unsafe fn testResolveGenericFunctionBounds() throws (testing::TestError) {
3759
    for program in [
3760
        @embed("lang/resolver/tests/fixtures/generic_application/linear_copy.rad"),
3761
        @embed("lang/resolver/tests/fixtures/generic_application/unbounded_copy.rad"),
3762
    ] {
3763
        let mut a = testResolver();
3764
        let result = try resolveProgramStr(&mut a, program);
3765
        try expectErrorKind(&result, resolver::ErrorKind::Bracket(
3766
            resolver::BracketError::RequiresCopy
3767
        ));
3768
    }
3769
    let mut a = testResolver();
3770
    let result = try resolveProgramStr(
3771
        &mut a, "fn f[T: Copy]() {} fn forward[T: Copy]() { f[T](); }"
3772
    );
3773
    try expectNoErrors(&result);
3774
}