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
Alexis Sellier committed ago 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 +
}