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