- Don't reprint entire items when attrs are added/removed. Probably all that's
needed is to add full SeqItem support for Attribute. It may also be helpful
to make `Block` a splice point, so that function signatures can be changed
without reprinting the entire body.
- General purpose conversion collapser. See json-c `rs/README.md` for an
explanation.
- struct_assign_to_update fails if the struct is actually a reference. For
example, it turns `r.f = 1` into `r = S { f: 1, .. r }`, when it should use
`*r` in both places.
- In general, it might be useful to have a pass that makes adjustments
explicit, and another to make them implicit again (maybe using a trace from
the first pass?)
- Ownership: re-enable "suspicious mono" checking. The goal is to remove
monomorphizations that are allowed by the inferred polymorphic but aren't
likely to be implementable under the Rust type system. Mainly this is for
getting rid of `WRITE -> MOVE` monomorphizations of generic accessors (they
should have only `WRITE -> WRITE` and `READ -> READ` monos). There is code
for finding suspicious monos in `mono_filter.rs`, but it's currently disabled
because removing the suspicious monos too early causes `ownership::inst` to
fail. We probably need a separate transform that can be run at the very end
to find and remove suspicious monos.
- Bad failure modes in ownership analysis. Ex: forgetting to mark `free` and
related functions as taking MOVE pointers causes json-c analysis to fail,
with `inst` unable to find a solution. This is partly caused by it inferring
the `data.c_object` union variant as `WRITE` instead of `MOVE`. Another
contributing factor is the generation of `MOVE` monos which can't actually be
solved with the given static var assignment. (We may need to let `inst`
reject a mono. This would require turning `inst` into a fixpoint analysis,
removing all invalid monos.)
- When ownership analysis fails, it fails in different ways on different runs,
due to hash table randomization (it iterates hash tables in several places).
This includes failing on different functions, as well as hanging
(backtracking forever) inside `inst`. We should fix this so at least it
fails reproducibly.
- The "collection hack" in the ownership analysis works well for libjson-c, but
is probably not suitable for all codebases. At some point we may need a way
to selectively disable the collection hack for certain functions or modules.
- Convert type_eq to analyze MIR instead of AST/HIR. This makes the analysis
simpler (no need to worry about operator overloads, for example), but makes
it harder to match `ty::Ty`s to `ast::Ty`s.
- Right now the ownership analysis runs on `optimized_mir` from the `TyCtxt`.
Eventually `rustc` is likely to get enough MIR optimizations (such as
inlining) that this is no longer desirable. Unfortunately, by the time we
get access to a `TyCtxt`, the previous versions of the MIR (such as
`mir_const`) are no longer available (the `Steal` has been stolen). We may
need more invasive driver changes to make this work.