.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
lang/
alloc/
ast/
gen/
il/
layout/
lower/
manifest/
module/
parser/
resolver/
tests/
fixtures/
core.rad
161.9 KiB
opacity.rad
14.5 KiB
regions.rad
41.7 KiB
safety.rad
191.8 KiB
structure.rad
188.8 KiB
metadata.rad
2.6 KiB
printer.rad
33.0 KiB
refs.rad
66.5 KiB
tests.rad
23.6 KiB
scanner/
sexpr/
alloc.rad
1.2 KiB
ast.rad
36.0 KiB
gen.rad
513 B
il.rad
48.5 KiB
layout.rad
6.9 KiB
lower.rad
487.6 KiB
manifest.rad
22.5 KiB
module.rad
17.8 KiB
package.rad
1.5 KiB
parser.rad
114.1 KiB
pretty.rad
103.6 KiB
resolver.rad
508.1 KiB
scanner.rad
19.3 KiB
sexpr.rad
7.1 KiB
strings.rad
3.3 KiB
types.rad
620 B
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/lang/resolver/tests/core.rad
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 | } |