.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/opacity.rad
raw
| 1 | //! Resolver tests: module-private opaque record representations. |
| 2 | |
| 3 | use std::io; |
| 4 | use std::testing; |
| 5 | use std::lang::resolver; |
| 6 | use std::lang::resolver::tests::*; |
| 7 | |
| 8 | /// Module that declares opaque records, an unexported opaque record, and operations on them. |
| 9 | constant MODEL: *[u8] = |
| 10 | "export opaque record Value: Copy { number: u32 } export opaque record Word(u32): Copy; export opaque record Empty: Copy {} opaque record Hidden: Copy { number: u32 } export fn hidden() -> Hidden { return Hidden { number: 42 }; } export fn make(number: u32) -> Value { return Value { number }; } export union Wrapped: Copy { Value(Value) }"; |
| 11 | |
| 12 | /// Resolve `program` as the root module with `MODEL` registered as its child `model`, |
| 13 | /// and require the given error kind. |
| 14 | unsafe fn expectModelError(program: *[u8], kind: resolver::ErrorKind) throws (testing::TestError) { |
| 15 | let mut a = testResolver(); |
| 16 | let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", program); |
| 17 | try registerModule(&mut super::MODULE_GRAPH, rootId, "model", MODEL); |
| 18 | let result = try resolveModuleTree(&mut a, rootId); |
| 19 | try expectErrorKind(&result, kind) catch error { |
| 20 | io::print(program); |
| 21 | io::print("\n"); |
| 22 | resolver::printer::printDiagnostics(&result.diagnostics, &a); |
| 23 | throw error; |
| 24 | }; |
| 25 | } |
| 26 | |
| 27 | /// Resolve `program` as the root module with `MODEL` registered as its child `model`, |
| 28 | /// and require no errors. |
| 29 | unsafe fn expectModelOk(program: *[u8]) throws (testing::TestError) { |
| 30 | let mut a = testResolver(); |
| 31 | let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", program); |
| 32 | try registerModule(&mut super::MODULE_GRAPH, rootId, "model", MODEL); |
| 33 | let result = try resolveModuleTree(&mut a, rootId); |
| 34 | try expectNoErrors(&result) catch error { |
| 35 | io::print(program); |
| 36 | io::print("\n"); |
| 37 | resolver::printer::printDiagnostics(&result.diagnostics, &a); |
| 38 | throw error; |
| 39 | }; |
| 40 | } |
| 41 | |
| 42 | /// Reading, writing, borrowing, and destructuring fields outside the defining module is rejected. |
| 43 | @test unsafe fn testOpaqueRecordFieldAccess() throws (testing::TestError) { |
| 44 | let programs = &[ |
| 45 | "mod model; fn f(p: model::Value) -> u32 { return p.number; }", |
| 46 | "mod model; fn f(p: &model::Value) -> u32 { return p.number; }", |
| 47 | "mod model; fn f(p: &mut model::Value) { set p.number = 1; }", |
| 48 | "mod model; fn f(p: &mut model::Value) { set p.number += 1; }", |
| 49 | "mod model; fn f(p: &model::Value) { let field = &p.number; }", |
| 50 | "mod model; fn f(p: &mut model::Value) { let field = &mut p.number; }", |
| 51 | "mod model; unsafe fn f(p: model::Value) -> u32 { return p.number; }", |
| 52 | "mod model; fn f() { unsafe { let p = model::make(1); let n = p.number; } }", |
| 53 | "mod model; fn f() -> u32 { return model::hidden().number; }", |
| 54 | "mod model; fn f(p: model::Word) -> u32 { return *p; }", |
| 55 | "mod model; fn f(p: &mut model::Word) { set **p = 2; }", |
| 56 | "mod model; fn f(p: model::Word) { let field = &*p; }", |
| 57 | "mod model; fn f(p: &mut model::Word) { let field = &mut **p; }", |
| 58 | "mod model; unsafe fn f(p: model::Word) -> u32 { return *p; }", |
| 59 | "mod model; use root::model::*; fn f(p: Value) -> u32 { return p.number; }", |
| 60 | ]; |
| 61 | for program in programs { |
| 62 | try expectModelError(program, resolver::ErrorKind::OpaqueRecordAccess); |
| 63 | } |
| 64 | } |
| 65 | |
| 66 | /// Constructing an opaque record outside the defining module is rejected. |
| 67 | @test unsafe fn testOpaqueRecordConstruction() throws (testing::TestError) { |
| 68 | let programs = &[ |
| 69 | "mod model; fn f() -> model::Value { return model::Value { number: 1 }; }", |
| 70 | "mod model; fn f() -> model::Value { return { number: 1 }; }", |
| 71 | "mod model; fn f() -> ?model::Value { return { number: 1 }; }", |
| 72 | "mod model; fn f() -> model::Value { return model::Value { .. }; }", |
| 73 | "mod model; fn f() -> model::Empty { return model::Empty {}; }", |
| 74 | "mod model; fn f() -> model::Empty { return {}; }", |
| 75 | "mod model; fn f() -> model::Word { return model::Word(1); }", |
| 76 | "mod model; unsafe fn f() -> model::Value { return model::Value { number: 1 }; }", |
| 77 | "mod model; static V: model::Value = model::Value { number: 1 };", |
| 78 | "mod model; use root::model::*; fn f() -> Word { return Word(1); }", |
| 79 | ]; |
| 80 | for program in programs { |
| 81 | try expectModelError(program, resolver::ErrorKind::OpaqueRecordAccess); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | /// Destructuring an opaque record in any pattern position outside the defining module is rejected. |
| 86 | @test unsafe fn testOpaqueRecordPatterns() throws (testing::TestError) { |
| 87 | let programs = &[ |
| 88 | "mod model; fn f(p: model::Value) { let case model::Value { number } = p else panic; }", |
| 89 | "mod model; fn f(p: &model::Value) { let case model::Value { number } = p else panic; }", |
| 90 | "mod model; fn f(p: model::Value) { let case model::Value { .. } = p else panic; }", |
| 91 | "mod model; fn f(p: model::Value) { if let case model::Value { number } = p; number > 0 {} }", |
| 92 | "mod model; fn f(p: model::Value) { while let case model::Value { number } = p { break; } }", |
| 93 | "mod model; fn f(p: model::Value) { match p { case model::Value { number } => {} } }", |
| 94 | "mod model; fn f(p: model::Wrapped) { match p { case model::Wrapped::Value(model::Value { number }) => {} } }", |
| 95 | "mod model; fn f(p: model::Wrapped) { if let case model::Wrapped::Value(model::Value { number }) = p {} }", |
| 96 | "mod model; fn f(p: model::Word) { let case model::Word(number) = p else panic; }", |
| 97 | "mod model; fn f(p: model::Word) { match p { case model::Word(number) => {} } }", |
| 98 | "mod model; unsafe fn f(p: model::Value) { let case model::Value { number } = p else panic; }", |
| 99 | "mod model; fn f(p: ?model::Value) { match p { case model::Value { number } => {}, else => {} } }", |
| 100 | "mod model; fn f(p: ?model::Value) { match p { case model::Value { .. } => {}, else => {} } }", |
| 101 | "mod model; fn f(p: &?model::Value) { match p { case model::Value { number: _ } => {}, else => {} } }", |
| 102 | "mod model; fn f(p: ?model::Word) { match p { case model::Word(number) => {}, else => {} } }", |
| 103 | "mod model; fn f(p: ?model::Word) { if let case model::Word(_) = p {} }", |
| 104 | ]; |
| 105 | for program in programs { |
| 106 | try expectModelError(program, resolver::ErrorKind::OpaqueRecordAccess); |
| 107 | } |
| 108 | } |
| 109 | |
| 110 | /// A method declared outside the defining module cannot access the representation. |
| 111 | @test unsafe fn testOpaqueRecordMethodOutsideModule() throws (testing::TestError) { |
| 112 | let programs = &[ |
| 113 | "mod model; export fn (v: &model::Value) read() -> u32 { return v.number; }", |
| 114 | "mod model; export fn (v: &mut model::Value) bump() { set v.number += 1; }", |
| 115 | "mod model; export fn (v: &model::Word) read() -> u32 { return **v; }", |
| 116 | ]; |
| 117 | for program in programs { |
| 118 | try expectModelError(program, resolver::ErrorKind::OpaqueRecordAccess); |
| 119 | } |
| 120 | // A method that only uses the module's operations is fine. |
| 121 | try expectModelOk( |
| 122 | "mod model; fn (v: &model::Value) copyOf() -> model::Value { return *v; } fn f() -> model::Value { let v = model::make(1); return v.copyOf(); }" |
| 123 | ); |
| 124 | } |
| 125 | |
| 126 | /// Child and sibling modules of the defining module cannot access the representation. |
| 127 | @test unsafe fn testOpaqueRecordModuleBoundary() throws (testing::TestError) { |
| 128 | let access = "use root::model; fn f(p: model::Value) -> u32 { return p.number; }"; |
| 129 | for inChild in [false, true] { |
| 130 | let mut a = testResolver(); |
| 131 | let rootId = try registerModule( |
| 132 | &mut super::MODULE_GRAPH, nil, "root", "export mod model; mod client;" |
| 133 | ); |
| 134 | let modelId = try registerModule( |
| 135 | &mut super::MODULE_GRAPH, |
| 136 | rootId, |
| 137 | "model", |
| 138 | "mod child; export opaque record Value: Copy { number: u32 }" |
| 139 | ); |
| 140 | try registerModule(&mut super::MODULE_GRAPH, modelId, "child", access if inChild else ""); |
| 141 | try registerModule(&mut super::MODULE_GRAPH, rootId, "client", "" if inChild else access); |
| 142 | let result = try resolveModuleTree(&mut a, rootId); |
| 143 | try expectErrorKind(&result, resolver::ErrorKind::OpaqueRecordAccess); |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | /// The defining module uses every form of access. |
| 148 | @test unsafe fn testOpaqueRecordLocalAccess() throws (testing::TestError) { |
| 149 | try expectAnalyzeOk( |
| 150 | "opaque record Value: Copy { number: u32 } opaque record Word(u32): Copy; opaque record Empty: Copy {} union Wrapped: Copy { Value(Value) } fn (v: &mut Value) bump() { set v.number += 1; } fn f() { let mut p = Value { number: 1 }; set p.number += 2; p.bump(); let q: Value = { number: p.number }; let r: ?Value = { number: 4 }; let e = Empty {}; let case Value { number } = q else panic; if let case Value { number: n } = p; n > 0 {} while let case Value { number: n } = p { break; } match p { case Value { number: n } => {} else => {} } let w = Word(1); let case Word(n) = w else panic; match Wrapped::Value(p) { case Wrapped::Value(Value { number }) => {} } } fn g() { let mut w = Word(1); set *w = 2; { let field = &mut *w; set *field = 3; } }" |
| 151 | ); |
| 152 | } |
| 153 | |
| 154 | /// Values of an opaque record can be passed, returned, moved, copied, and compared anywhere. |
| 155 | @test unsafe fn testOpaqueRecordValuesAllowed() throws (testing::TestError) { |
| 156 | let programs = &[ |
| 157 | "mod model; fn f() -> model::Value { return model::make(1); }", |
| 158 | "mod model; fn f(p: model::Value) -> model::Value { return p; }", |
| 159 | "mod model; fn f(p: model::Value) -> model::Value { let q = p; let r = q; return r; }", |
| 160 | "mod model; fn f(p: &mut model::Value, q: model::Value) { set *p = q; }", |
| 161 | "mod model; fn f(p: &model::Value) -> model::Value { return *p; }", |
| 162 | "mod model; fn f(p: model::Value, q: model::Value) -> bool { return p == q; }", |
| 163 | "mod model; fn f(p: model::Word, q: model::Word) -> bool { return p == q; }", |
| 164 | "mod model; fn f(p: model::Wrapped) -> bool { match p { case model::Wrapped::Value(v) => { return true; } } }", |
| 165 | "mod model; record Holder: Copy { v: model::Value } fn f(v: model::Value) -> Holder { return Holder { v }; }", |
| 166 | "mod model; fn f(v: model::Value) -> [model::Value; 2] { return [v, v]; }", |
| 167 | ]; |
| 168 | for program in programs { |
| 169 | try expectModelOk(program); |
| 170 | } |
| 171 | } |
| 172 | |
| 173 | /// Safe `undefined` cannot forge an opaque record, even when all of its fields are integers. |
| 174 | @test unsafe fn testOpaqueRecordUndefinedRequiresUnsafe() throws (testing::TestError) { |
| 175 | let programs = &[ |
| 176 | "mod model; fn f() -> model::Value { return undefined; }", |
| 177 | "mod model; fn f() -> model::Word { return undefined; }", |
| 178 | "mod model; fn f() -> model::Empty { return undefined; }", |
| 179 | "mod model; fn take(w: model::Word) {} fn f() { take(undefined); }", |
| 180 | "mod model; fn f() -> [model::Value; 2] { return undefined; }", |
| 181 | "mod model; record Holder: Copy { v: model::Value } fn f() -> Holder { return undefined; }", |
| 182 | "mod model; static W: model::Word = undefined;", |
| 183 | ]; |
| 184 | for program in programs { |
| 185 | try expectModelError(program, resolver::ErrorKind::UnsafeOperation); |
| 186 | } |
| 187 | // A safe local must be assigned before it is read. |
| 188 | try expectModelError( |
| 189 | "mod model; fn f() -> model::Word { let x: model::Word = undefined; return x; }", |
| 190 | resolver::ErrorKind::UninitializedUse("x") |
| 191 | ); |
| 192 | try expectModelError( |
| 193 | "mod model; fn f() -> model::Value { let x: model::Value = undefined; return x; }", |
| 194 | resolver::ErrorKind::UninitializedUse("x") |
| 195 | ); |
| 196 | // Unsafe code and definite assignment remain available. |
| 197 | try expectModelOk("mod model; unsafe fn f() -> model::Word { return undefined; }"); |
| 198 | try expectModelOk( |
| 199 | "mod model; fn f() -> model::Value { let mut x: model::Value = undefined; set x = model::make(1); return x; }" |
| 200 | ); |
| 201 | } |
| 202 | |
| 203 | /// Child modules of the defining module are not exempt from the `undefined` rule. |
| 204 | @test unsafe fn testOpaqueRecordUndefinedModuleBoundary() throws (testing::TestError) { |
| 205 | let mut a = testResolver(); |
| 206 | let rootId = try registerModule(&mut super::MODULE_GRAPH, nil, "root", "export mod model;"); |
| 207 | let modelId = try registerModule( |
| 208 | &mut super::MODULE_GRAPH, |
| 209 | rootId, |
| 210 | "model", |
| 211 | "mod child; export opaque record Word(u32): Copy;" |
| 212 | ); |
| 213 | try registerModule( |
| 214 | &mut super::MODULE_GRAPH, |
| 215 | modelId, |
| 216 | "child", |
| 217 | "use root::model; fn f() -> model::Word { return undefined; }" |
| 218 | ); |
| 219 | let result = try resolveModuleTree(&mut a, rootId); |
| 220 | try expectErrorKind(&result, resolver::ErrorKind::UnsafeOperation); |
| 221 | } |
| 222 | |
| 223 | /// The defining module can still use `undefined` for its all-integer opaque records. |
| 224 | @test unsafe fn testOpaqueRecordUndefinedLocalAllowed() throws (testing::TestError) { |
| 225 | let programs = &[ |
| 226 | "opaque record Word(u32): Copy; fn f() -> u32 { let w: Word = undefined; return *w; }", |
| 227 | "opaque record Word(u32): Copy; fn f() -> Word { return undefined; }", |
| 228 | "opaque record Value: Copy { number: u32 } fn f() -> [Value; 2] { return undefined; }", |
| 229 | "opaque record Value: Copy { number: u32 } record Holder: Copy { v: Value } fn f() -> Holder { return undefined; }", |
| 230 | "opaque record Value: Copy { number: u32 } static V: Value = undefined;", |
| 231 | ]; |
| 232 | for program in programs { |
| 233 | try expectAnalyzeOk(program); |
| 234 | } |
| 235 | } |
| 236 | |
| 237 | /// An opaque record outside its module is not valid when zero-filled, so it cannot be storage. |
| 238 | @test unsafe fn testOpaqueRecordDefaultStorageRejected() throws (testing::TestError) { |
| 239 | let programs = &[ |
| 240 | "mod model; @default fn main(a: *mut model::Value) -> i32 { return 0; }", |
| 241 | "mod model; @default fn main(a: *mut [model::Value; 2]) -> i32 { return 0; }", |
| 242 | "mod model; @default fn main(a: *mut model::Word) -> i32 { return 0; }", |
| 243 | "mod model; record S { n: u32, v: model::Value } @default fn main(a: *mut S) -> i32 { return 0; }", |
| 244 | "mod model; record S { v: [model::Word; 4] } @default fn main(a: *mut S) -> i32 { return 0; }", |
| 245 | ]; |
| 246 | for program in programs { |
| 247 | try expectModelError(program, resolver::ErrorKind::DefaultStorageNotZeroValid); |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | /// An opaque record is valid when zero-filled in its defining module, and an |
| 252 | /// optional one is `nil` anywhere. |
| 253 | @test unsafe fn testOpaqueRecordDefaultStorageAllowed() throws (testing::TestError) { |
| 254 | let programs = &[ |
| 255 | "opaque record Value: Copy { number: u32 } @default fn main(a: *mut Value) -> i32 { return 0; }", |
| 256 | "opaque record Value: Copy { number: u32 } record S { v: [Value; 2] } @default fn main(a: *mut S) -> i32 { return 0; }", |
| 257 | "mod model; @default fn main(a: *mut ?model::Value) -> i32 { return 0; }", |
| 258 | "mod model; record S { v: [?model::Value; 2] } @default fn main(a: *mut S) -> i32 { return 0; }", |
| 259 | ]; |
| 260 | for program in programs { |
| 261 | try expectModelOk(program); |
| 262 | } |
| 263 | } |