lang: Retain shared cursor input dependencies
8b952af5fdd03efd723d49d5f8aaee41b52c76125aa9010dfcfe5d5a9a5354b6
A token from an implicitly borrowed input added a loan on the reader that held the input. Keeping the token then blocked later cursor calls. Retain shared input dependencies directly without a loan on their holder. Keep exclusive dependencies and mutable view loans protected. Cover retained tokens and conflicting writes through a mutable view. Assisted-by: Codex:gpt-6
1 parent
96692761
lib/std/lang/resolver/refs.rad
+10 -0
| 110 | 110 | if let case SymbolData::Region { mutable: false, .. } = self.symbols[*sym].data { |
|
| 111 | 111 | return region; |
|
| 112 | 112 | } |
|
| 113 | 113 | } |
|
| 114 | 114 | } |
|
| 115 | + | // Shared dependencies keep their storage borrowed without a loan on its holder. |
|
| 116 | + | if not exclusive and sources(region).len > 0 { |
|
| 117 | + | let mut shared = true; |
|
| 118 | + | for source in sources(region) { |
|
| 119 | + | set shared = shared and not source.exclusive; |
|
| 120 | + | } |
|
| 121 | + | if shared { |
|
| 122 | + | return dependency(self, regionBound, sources(region)); |
|
| 123 | + | } |
|
| 124 | + | } |
|
| 115 | 125 | let mut retained: *mut [Source] = &mut []; |
|
| 116 | 126 | try! retained.extend(sources(region), self.arena); |
|
| 117 | 127 | let source = Source { node, binding: nil, exclusive }; |
|
| 118 | 128 | try! retained.append(source, self.arena); |
|
| 119 | 129 | return dependency(self, regionBound, &retained[..]); |
lib/std/lang/resolver/tests/regions.rad
+15 -0
| 914 | 914 | "fn read(v: &u32, w: &u32, c: bool) -> u32 { return *select(v, w, c); }", |
|
| 915 | 915 | ] |
|
| 916 | 916 | ) |
|
| 917 | 917 | ); |
|
| 918 | 918 | } |
|
| 919 | + | ||
| 920 | + | /// Shared cursor contents remain live across independent cursor advances. |
|
| 921 | + | @test unsafe fn testImplicitCursorContentSource() throws (testing::TestError) { |
|
| 922 | + | try expectAnalyzeOk( |
|
| 923 | + | "record Reader['src] { bytes: &'src [u8], pos: u32 } union Token['src]: Copy { Text(&'src [u8]), Number(u8) } fn (r: &mut Reader['src]) next() -> ?Token['src] { if r.pos == r.bytes.len { return nil; } let at = r.pos; set r.pos += 1; return Token::Text(&r.bytes[at .. at + 1]); } fn demo() { let input: [u8; 2] = ['a', 'b']; let mut reader = Reader { bytes: &input[..], pos: 0 }; let first = reader.next() else return; let second = reader.next() else return; }" |
|
| 924 | + | ); |
|
| 925 | + | } |
|
| 926 | + | ||
| 927 | + | /// Shared results from mutable contents keep conflicting writes excluded. |
|
| 928 | + | @test unsafe fn testImplicitMutableCursorContentLoan() throws (testing::TestError) { |
|
| 929 | + | try expectProgramError( |
|
| 930 | + | "record Reader['src] { bytes: &'src mut [u8] } fn (r: &'v mut Reader['src]) input() -> &'v [u8] { return &r.bytes[..]; } fn demo() { let mut input: [u8; 2] = [1, 2]; let mut reader = Reader { bytes: &mut input[..] }; let first = reader.input(); set reader.bytes[0] = 3; assert first[0] == 1; }", |
|
| 931 | + | resolver::ErrorKind::BorrowConflict("reader") |
|
| 932 | + | ); |
|
| 933 | + | } |
test/tests/region.cursor.implicit.rad
added
+41 -0
| 1 | + | //! returns: 0 |
|
| 2 | + | ||
| 3 | + | /// Reader with an independent shared input and a mutable cursor. |
|
| 4 | + | record Reader['src] { |
|
| 5 | + | /// Shared input bytes. |
|
| 6 | + | bytes: &'src [u8], |
|
| 7 | + | /// Next unread byte. |
|
| 8 | + | pos: u32, |
|
| 9 | + | } |
|
| 10 | + | ||
| 11 | + | /// Token reached through shared input storage. |
|
| 12 | + | union Token['src]: Copy { |
|
| 13 | + | /// Bytes of the token. |
|
| 14 | + | Text(&'src [u8]), |
|
| 15 | + | /// Decoded number. |
|
| 16 | + | Number(u8), |
|
| 17 | + | } |
|
| 18 | + | ||
| 19 | + | /// Advance the cursor and retain the input as the token source. |
|
| 20 | + | fn (r: &mut Reader['src]) next() -> ?Token['src] { |
|
| 21 | + | if r.pos == r.bytes.len { |
|
| 22 | + | return nil; |
|
| 23 | + | } |
|
| 24 | + | let at = r.pos; |
|
| 25 | + | set r.pos += 1; |
|
| 26 | + | return Token::Text(&r.bytes[at .. at + 1]); |
|
| 27 | + | } |
|
| 28 | + | ||
| 29 | + | /// Tokens retain their input while the reader advances to later tokens. |
|
| 30 | + | @default fn main() -> u32 { |
|
| 31 | + | let input: [u8; 2] = ['a', 'b']; |
|
| 32 | + | let mut reader = Reader { bytes: &input[..], pos: 0 }; |
|
| 33 | + | let first = reader.next() else panic; |
|
| 34 | + | let second = reader.next() else panic; |
|
| 35 | + | assert reader.next() == nil; |
|
| 36 | + | let case Token::Text(a) = first else panic; |
|
| 37 | + | let case Token::Text(b) = second else panic; |
|
| 38 | + | assert a[0] == 'a'; |
|
| 39 | + | assert b[0] == 'b'; |
|
| 40 | + | return 0; |
|
| 41 | + | } |