1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
# TODO
0. derive [ord] for types
1. stateful maps/sets modules (hashtbl?)
1. Check the occurrence of visitors like visit_AEndedMutLoan: the parameters are
sometimes inverted!
0. compute the region constraints for the type definitions
2. set of types with mutable borrows (what to do when type variables appear under
shared borrows?), nested borrows...
necessary to know what to return.
2. check types are not "infinite"
3. in MIR, erased regions are completely erased (no list of erased regions...):
update functions like `ty_has_regions` (and rename to `ty_has_borrows`),
`erase_regions`
4. check that no borrow_overwrites upon ending abstractions
5. add a check in function inputs: ok to take as parameters symbolic values with
borrow parameters *if* they come from the "input abstractions".
In order to do this, add a symbolic value kind (would make things easier than
adding ad-hoc lookups...): `FunRet`, `FunGivenBack`, `SynthInput`, `SynthGivenBack`
Rk.: pay attention: we can't give borrows of borrows to functions, but borrows
are ok.
6. add `mvalue` (meta values) stored in abstractions when ending loans
7. fix the static regions (with projectors)
Before that, introduce a sanity check to make sure we don't use static regions.
8. The following doesn't work:
```
fn f1<'c, T>(p : (&'c mut T, &'c mut T)) -> (&'c mut T, &'c mut T)
fn f2<'a, 'b, T>(p: (&'a mut T, &'b mut T)) -> (&'a mut T, &'b mut T)
let p1 = f1<'c>(p0);
let p2 = f2<'a, 'b>(p1);
```
(end borrows)
I think we should change the proj_loans to:
`AProjLoans of symbolic_value * (mvalue * aproj) list`
(to accumulate the given back values)
Then, once we collected all the borrows, we would convert it to:
`AEndedProjLoans of (mvalue * aproj) list`
If the list is empty, it means the value was not modified.
* write a function to check that the code we are about to synthesize is in the proper
subset. In particular:
* borrow overwrites
* type parameters instantiation
* uniform polymorphism
Also, write nice debug messages which refer to the original code in case
something fails.
* write an interesting example to study with Jonathan
* add option for: `allow_borrow_overwrites_on_input_values`
(rather: `will_overwrite_input_borrows`)
(but always disallow borrow overwrites on returned values)
at the level of abstractions (not at the level of loans!)
* invariant: if there is a `proj_loans rset1 (s:rty)` where `s` contains mutable
borrows, then:
* either there is exactly one `s` in the current context
* or there is exactly one `proj_borrows rset2 (s:rty<:rty')` which intersects
the `proj_loans ...`
However, one `proj_borrows s` may intersect several `proj_loans` (in which
case we will need to split the value given back - for now: disallow this
behaviour?).
* remove the rule which says that we can end a borrow under an abstraction if
the corresponding loan is in the same abstraction.
Actually: update the rule, rather.
* update end_borrow_get_borrow to keep track of the ignored borrows/loans as
outer borrows, and track the ids of the ignored shared loans?
or: make sure there are no parent abstractions when ending inner loans in
abstractions.
* `ended_proj_loans` (with ghost value)
* make the projected shared borrows more structured? I don't think that's necessary
* add a `allow_borrow_overwrites` in the loan projectors.
* During printing, contexts are often big, with many variables containing "bottom".
Some variables also actually never get assigned, especially when they are used
for auxiliary assignments which don't exist anymore (because they were merged
with other operations - for arithmetic operations, for instance).
Maybe we should register which variable has been assigned at least once, and
print only those (thus skipping a big part of the environment for some time).
* Some variables have the same name. It might be good to also print their id
to disambiguate?
* it would be good to find a "core", which implements the rules (like
"end_borrow") and on top of which we build more complex functions which
chose in which order to apply the rules, etc. This way we would make very
explicit where we need to insert sanity checks, what the preconditions are,
where invariants might be broken, etc.
* intensively test with PLT-redex
* remove the config parameters when they are useless
# DONE
* update the assignment to move the destination value (which will be overriden)
to a dummy variable, and end all the outer borrows.
Also update pop_frame.
* Check what happens when symbolic borrows are not expanded (when looking for
borrows/abstractions to end).
* Detect loops in end_borrow/end_abstraction
* recheck give_back_symbolic_value (use regions!)
* expand symbolic values which are primitively copyable upon using them as
function arguments or putting them in the return value, in order to deduplicate
those values.
Completion: we expand those values only upon copying them (that's enough).
* invariant: if a symbolic value is present multiple times in the concrete environment,
it means it is primitively copyable
* update the printing of mut_borrows and mut_loans ([s@0 <: ...]) and (s@0)
* add a switch to allow general symbolic values (containing references, etc.)
or not.
* split `apply_proj_borrows` into two:
* `apply_proj_borrows_on_input_values` : ... -> value -> rty -> avalue
* `apply_proj_borrows_on_given_back_values` : ... -> value -> avalue -> avalue
Actually: didn't do it: bad idea.
* Reduce projectors to `_` (ignored) when there are no region intersections
* Add a `Collections.ml` file, with `Map` and `Set`
|
