Constants in patterns can contain equality-less types

[petrochenkov]

Code:

const C: *const str = "abcd";

fn main() {
    match C {
        C => {}
        _ => {}
    }
}

Diagnostics:

warning: broken MIR (Terminator { source_info: SourceInfo { span: <anon>:5:9: 5:10, scope: scope0 }, kind: tmp1 = <str as std::cmp::PartialEq>::eq(tmp0, const "abcd") -> bb3 }): bad arg #0 (&str <- *const str): Sorts(ExpectedFound { expected: &str, found: *const str })
 --> <anon>:4:11
  |>
4 |>     match C {
  |>           ^

Reproduces on stable/beta/nightly.

[eddyb]

This is a pointer pattern, it shouldn't compile AFAIK. cc @arielb1

[arielb1]

This should be a constant pattern. Why it is destructuring through the pointer?

[nagisa]

As far as I remember, the constant-evaluated initializer expression gets used as a pattern, i.e. the code below and in the report are equivalent for MIR builder:

const C: *const str = "abcd";

fn main() {
    match C {
        "abcd" => {}
        _ => {}
    }
}

Which is caught by the proper-typeck and is why the mir-typeck is complaining.

[arielb1]

This is more general than raw pointers

const C: fn() = main;

fn foo(x: fn()) {
    match x {
        C => {}
        _ => {}
    }
}

fn main() {}

However, other cases result in a const-eval error:

const C: *const u8 = &0; //~ ERROR error: constant evaluation error: unimplemented constant expression: address operator [E0471]

fn foo(x: *const u8) {
    match x {
        C => {}
        _ => {}
    }
}

fn main() {}

I think this is the right solution.

[arielb1]

Problem line: https://github.com/rust-lang/rust/blob/1.10.0/src/librustc_const_eval/eval.rs#L340

[petrochenkov]

@arielb1 changed the title from warning: broken MIR: expected: &str, found: *const str to Constants in patterns can contain equality-less types

Since you generalized this issue, #34782 can probably be closed as a duplicate.

[arielb1]

cc @oli-obk

[petrochenkov]

One more test, for thin pointers:

const C: *const [u8; 4] = b"abcd";

fn main() {
    match C {
        C => {}
        _ => {}
    }
}

Gives internal compiler error: ../src/librustc_trans/collector.rs:983: find_vtable_types_for_unsizing: invalid coercion *const [u8; 4] -> &[u8] currently.

[oli-obk]

The issue is that the mir-building process calls eval_const_expr (

rust/src/librustc_mir/hair/cx/pattern.rs

Line 68 in f93aaf8

PatternKind::Constant { value: value }

) while the old trans calls consts::const_expr (

rust/src/librustc_trans/_match.rs

Line 288 in f93aaf8

let expr = consts::const_expr(ccx, &lit_expr, bcx.fcx.param_substs, None, Yes);

). The latter does things like unsizing and other coercion stuff.

It should work if instead of calling eval_const_expr we'd build a MIR for that expression and used the MIR-const evaluator on that MIR.

[arielb1]

@oli-obk

The problem is that the code compiles. We should not be doing *const T -> &T coercions, obviously.