lib/std/lang/resolver/tests/opacity.rad 14.5 KiB 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
}