Nightly ICE with non-const macro in const

[TomCrypto]

Offending snippet using serde_json:

pub const JSON: serde_json::Value = serde_json::json!({
    "foo": "bar"
});

The code shouldn't build, as per the first few errors below, but currently on nightly it also causes the compiler to panic. It does not panic on stable or beta.

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0017]: references in constants may only refer to immutable values
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^ constants require immutable values
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

error[E0493]: destructors cannot be evaluated at compile-time
 --> src/lib.rs:1:37
  |
1 |   pub const JSON: serde_json::Value = serde_json::json!({
  |  _____________________________________^
2 | |     "foo": "bar"
3 | | });
  | |__^ constants cannot evaluate destructors
  |
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

[ERROR rustc_mir::transform::qualify_consts] old validator: [(<::serde_json::macros::json_internal macros>:120:27: 120:51, "FnCallNonConst(DefId(15:468 ~ serde_json[1ca2]::map[0]::{{impl}}[0]::new[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "MutBorrow(Mut { allow_two_phase_borrow: true })"), (<::serde_json::macros::json_internal macros>:46:30: 46:53, "FnCallNonConst(DefId(2:2220 ~ core[f8ef]::convert[0]::Into[0]::into[0]))"), (<::serde_json::macros::json_internal macros>:123:27: 123:58, "FnCallNonConst(DefId(15:1765 ~ serde_json[1ca2]::value[0]::to_value[0]))"), (<::serde_json::macros::json_internal macros>:123:27: 123:70, "FnCallNonConst(DefId(2:5319 ~ core[f8ef]::result[0]::{{impl}}[5]::unwrap[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "FnCallNonConst(DefId(15:477 ~ serde_json[1ca2]::map[0]::{{impl}}[0]::insert[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "LiveDrop")]
[ERROR rustc_mir::transform::qualify_consts] new validator: [(<::serde_json::macros::json_internal macros>:120:27: 120:51, "FnCallNonConst(DefId(15:468 ~ serde_json[1ca2]::map[0]::{{impl}}[0]::new[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "MutBorrow(Mut { allow_two_phase_borrow: true })"), (<::serde_json::macros::json_internal macros>:46:30: 46:53, "FnCallNonConst(DefId(2:2220 ~ core[f8ef]::convert[0]::Into[0]::into[0]))"), (<::serde_json::macros::json_internal macros>:123:27: 123:58, "FnCallNonConst(DefId(15:1765 ~ serde_json[1ca2]::value[0]::to_value[0]))"), (<::serde_json::macros::json_internal macros>:123:27: 123:70, "FnCallNonConst(DefId(2:5319 ~ core[f8ef]::result[0]::{{impl}}[5]::unwrap[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "FnCallNonConst(DefId(15:477 ~ serde_json[1ca2]::map[0]::{{impl}}[0]::insert[0]))"), (<::serde_json::macros::json_internal macros>:46:11: 121:26, "LiveDrop"), (<::serde_json::macros::json_internal macros>:120:14: 120:24, "LiveDrop")]
error: internal compiler error: src/librustc_mir/transform/qualify_consts.rs:1038: Disagreement between legacy and dataflow-based const validators.
    After filing an issue, use `-Zsuppress-const-validation-back-compat-ice` to compile your code.
 --> src/lib.rs:1:1
  |
1 | / pub const JSON: serde_json::Value = serde_json::json!({
2 | |     "foo": "bar"
3 | | });
  | |___^

thread 'rustc' panicked at 'Box<Any>', src/librustc_errors/lib.rs:876:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.40.0-nightly (1721c9685 2019-10-12) running on x86_64-unknown-linux-gnu

note: compiler flags: -C codegen-units=1 -C debuginfo=2 --crate-type lib

note: some of the compiler flags provided by cargo are hidden

Version: 1.40.0-nightly (2019-10-12 1721c96)
Playground: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=5558c5ebe1ea55f66650422dffcf6d88

Quite possibly a duplicate of #65348 just buried inside the macro expansion but I'm not familiar enough with Rust compiler internals to make that determination.

[Centril]

cc @ecstatic-morse

[ecstatic-morse]

I've minimized this to the following:

const _: Vec<i32> = {
    let x = Vec::<i32>::new();
    let r = &mut x;
    let y = x;
    y 
};

A mutable reference is required in all variants of this, so this particular mismatch does not represent a true backwards compatibility hazard: Creating a reference that would allow mutation is forbidden in all const contexts. We could simply stop triggering the mismatch ICE when both lists contain the same MutBorrow error.

The underlying issue, however, is that IndirectlyMutableLocals is being too conservative once again. As soon as a mutable reference is taken to x, we use type-based qualification instead of looking at the NeedsDrop qualif which gets cleared when x is moved from. Increasing the precision here would require a DefinitelyMovedFrom dataflow analysis. This would get checked first whenever NeedsDrop was queried (much like how we currently check IndirectlyMutableLocals first). I believe this will be necessary when we do allow &mut in const contexts, otherwise writing code would be quite painful.

I could hack together a solution for this particular case that doesn't require another dataflow analysis. Basically, during validation, we could keep track of which Locals have been moved out of in the current basic block and use that as a conservative approximation of DefinitelyMovedFrom. This would fail if the local was moved from in one basic block and then dropped in a successor of that block. It seems relatively hard to write rust code that gets translated to that MIR, however. For example, the following does not do it, but I think it should be possible.

struct NeedsDrop(i32);

impl NeedsDrop {
    const fn add_one(self)-> Self {
        NeedsDrop(self.0 + 1)
    }
}

impl Drop for NeedsDrop {
    fn drop(&mut self) {}
}

const _: NeedsDrop = {
    let x = NeedsDrop(0);
    let r = &mut x;
    let y = x.add_one();
    y
};

[Centril]

cc @oli-obk @RalfJung @eddyb

[ecstatic-morse]

Checking for moves in the same block fails pretty often. I've implemented the first fix described above, but we probably want to use a MaybeInitializedLocals analysis in the long term.