Filter and test predicates using normalize_and_test_predicates for const-prop
#68297
Conversation
…const-prop Fixes rust-lang#68264 Previously, I attempted to use `substitute_normalize_and_test_predicates` to detect unsatisfiable bounds. Unfortunately, since const-prop runs in a generic environment (we don't have any of the function's generic parameters substituted), this could lead to cycle errors when attempting to normalize predicates. This check is replaced with a more precise check. We now only call `normalize_and_test_predicates` on predicates that have the possibility of being proved unsatisfiable - that is, predicates that don't depend on anything local to the function (e.g. generic parameters). This ensures that we don't hit cycle errors when we normalize said predicates, while still ensuring that we detect unsatisfiable predicates.
|
(rust_highfive has picked a reviewer for you, use r? to override) |
rust-highfive
added
the
S-waiting-on-review
|
Not my area of expertise. |
| .iter() | ||
| .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None }) | ||
| .collect(); | ||
| if !traits::normalize_and_test_predicates( |
There was a problem hiding this comment.
why call the function and not the query here?
There was a problem hiding this comment.
I didn't realize this was a query, lol.
EDIT: This isn't a query. Did you want me to query-ify this?
There was a problem hiding this comment.
well there's substitute_normalize_and_test_predicates which you used before.
There was a problem hiding this comment.
@oli-obk: That would use all of the predicates, which I needed to filter beforehand.
There was a problem hiding this comment.
Oh... sorry for not reading the docs properly. You're totally right. Let's merge this PR for now and experiment with making it a query separately. Such a query could share a lot of evaluation time between the predicate elaborations of completely independent definitions if they have the same predicate list.
|
It probably makes sense to add the test case I've provided in #68264 as regression test? |
|
@weiznich: Added |
| } | ||
| } | ||
|
|
||
| fn main() {} |
There was a problem hiding this comment.
The overflow only happens if the current crate is a library. It does not happen if it's a binary crate (containing a main function). That means this test tests something different.
There was a problem hiding this comment.
Passing --emit=mir causes the issue to occur for a binary crate, since it forces optimized_mir (and therefore const-prop) to get run on the 'bad' function.
You can verify this locally with rustc +nightly src/test/ui/consts/issue-68264-overflow.rs --emit=mir
|
@oli-obk: Are there any other changes that you'd like me to make? |
|
Nope, this just fell of my radar. Thanks for the ping @bors r+ |
|
📌 Commit 3fef3d8 has been approved by |
bors
added
S-waiting-on-bors
…, r=oli-obk Filter and test predicates using `normalize_and_test_predicates` for const-prop Fixes rust-lang#68264 Previously, I attempted to use `substitute_normalize_and_test_predicates` to detect unsatisfiable bounds. Unfortunately, since const-prop runs in a generic environment (we don't have any of the function's generic parameters substituted), this could lead to cycle errors when attempting to normalize predicates. This check is replaced with a more precise check. We now only call `normalize_and_test_predicates` on predicates that have the possibility of being proved unsatisfiable - that is, predicates that don't depend on anything local to the function (e.g. generic parameters). This ensures that we don't hit cycle errors when we normalize said predicates, while still ensuring that we detect unsatisfiable predicates. I haven't been able to come up with a minimization of the Diesel issue - however, I've verified that it compiles successfully.
Rollup of 8 pull requests Successful merges: - #67734 (Remove appendix from Apache license) - #67795 (Cleanup formatting code) - #68290 (Fix some tests failing in `--pass check` mode) - #68297 ( Filter and test predicates using `normalize_and_test_predicates` for const-prop) - #68302 (Fix #[track_caller] and function pointers) - #68339 (Add `riscv64gc-unknown-linux-gnu` into target list in build-manifest) - #68381 (Added minor clarification to specification of GlobalAlloc::realloc.) - #68397 (rustdoc: Correct order of `async` and `unsafe` in `async unsafe fn`s) Failed merges: r? @ghost
Fixes #68264
Previously, I attempted to use
substitute_normalize_and_test_predicatesto detect unsatisfiablebounds. Unfortunately, since const-prop runs in a generic environment
(we don't have any of the function's generic parameters substituted),
this could lead to cycle errors when attempting to normalize predicates.
This check is replaced with a more precise check. We now only call
normalize_and_test_predicateson predicates that have the possibilityof being proved unsatisfiable - that is, predicates that don't depend
on anything local to the function (e.g. generic parameters). This
ensures that we don't hit cycle errors when we normalize said
predicates, while still ensuring that we detect unsatisfiable
predicates.
I haven't been able to come up with a minimization of the Diesel issue - however, I've verified that it compiles successfully.