Compiler should report const fns that it can't evaluate

[jimblandy]

If I write this:

#![feature(const_fn)]

const X : usize = 2;

const fn f(x: usize) -> usize {
    let mut sum = 0;
    for i in 0..x {
        sum += i;
    }
    sum
}

#[allow(unused_variables)]
fn main() {
    let a : [i32; f(X)];
}

then I get the error message:

<anon>:10:5: 10:8 error: array length constant evaluation error: non-constant path in constant expression [E0250]
<anon>:10     sum
              ^~~
<anon>:10:5: 10:8 help: see the detailed explanation for E0250
<anon>:15:13: 15:24 note: for array length here
<anon>:15     let a : [i32; f(X)];
                      ^~~~~~~~~~~

If I understand correctly, the problem here is that although my f is declared to be a const fn, when the compiler tries evaluating the length of the array type [i32; f(X)], it finds it can't actually evaluate that function call at compile time.

As I understand it, the value of declaring a fn to be const is that it makes the function usable at compile time. When this isn't possible, the error message should blame the function, not the call.

[oli-obk]

That check exists. But it's called after the length evaluation for arrays. If you remove the array you'll see the proper errors:

<anon>:6:9: 6:20 error: blocks in constant functions are limited to items and tail expressions [E0016]
<anon>:6     let mut sum = 0;
                 ^~~~~~~~~~~
<anon>:6:9: 6:20 help: see the detailed explanation for E0016
<anon>:7:5: 9:6 error: blocks in constant functions are limited to items and tail expressions [E0016]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0016
<anon>:7:5: 9:6 error: blocks in constant functions are limited to items and tail expressions [E0016]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0016
<anon>:7:5: 9:6 error: constant function contains unimplemented expression type [E0019]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0019
<anon>:7:5: 9:6 error: function calls in constant functions are limited to constant functions, struct and enum constructors [E0015]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0015
<anon>:7:14: 7:18 error: constant function contains unimplemented expression type [E0019]
<anon>:7     for i in 0..x {
                      ^~~~
<anon>:7:14: 7:18 help: see the detailed explanation for E0019
<anon>:7:5: 9:6 error: constant function contains unimplemented expression type [E0019]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0019
<anon>:7:5: 9:6 error: constant function contains unimplemented expression type [E0019]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0019
<anon>:7:5: 9:6 error: function calls in constant functions are limited to constant functions, struct and enum constructors [E0015]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0015
<anon>:7:5: 9:6 error: references in constant functions may only refer to immutable values [E0017]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0017
<anon>:8:9: 8:17 error: blocks in constant functions are limited to items and tail expressions [E0016]
<anon>:8         sum += i;
                 ^~~~~~~~
<anon>:8:9: 8:17 help: see the detailed explanation for E0016
<anon>:8:9: 8:17 error: constant function contains unimplemented expression type [E0019]
<anon>:8         sum += i;
                 ^~~~~~~~
<anon>:8:9: 8:17 help: see the detailed explanation for E0019
<anon>:7:5: 9:6 error: constant function contains unimplemented expression type [E0019]
<anon>:7     for i in 0..x {
<anon>:8         sum += i;
<anon>:9     }
<anon>:7:5: 9:6 help: see the detailed explanation for E0019

[pnkfelix]

Still, the problem report here is legitimate, in the sense that the error message here is not helpful to a novice user.

[oli-obk]

We could generically blame the function. But where would you like to report the following error:

const fn add(a: u8, b: u8) -> u8 { a + b }

fn main() {
    let a: [i32, add(200, 200) as usize];
}

the only reason this fails, is because you chose arguments to the function that will cause the function to fail.

Another alternative is to only blame the function, if the error occurring is a NonConstPath, but then which error should we report here:

const fn add(a: u8, b: u8) -> u8 { 200 + 200 + a + b }

fn main() {
    let a: [i32, add(1, 1) as usize];
}

[pnkfelix]

@oli-obk What about moving the checking of const-fn bodies (that they conform to the rules for const fn) to an earlier stage? Both of the examples you gave were valid const fn, but the original report is using a clearly invalid const fn, right?

[oli-obk]

Good point. I'll evaluate if that works, but I don't see why it shouldn't.

[oli-obk]

We can move most checks to an earlier stage, but the checks for the tail expression can't be moved, since the tail expression is just like any other const expression, it is checked by check_const to make sure it doesn't contain bogus stuff, and check_const expects typeck to have been completed.

[pnkfelix]

@oli-obk okay, thanks for looking into that.

If we wanted to continue down this tack, it sounds like we could divide the const fn analysis into two parts: the first could happen at the earlier stage (and would presumably be a relatively simple-minded analysis that the body roughly matches the structure we expect), while the tail-expression checking would be put into the second part of the analysis.

[pnkfelix]

(i suspect we could even incorporate the early stage analysis for const fn into the parser...)

[oli-obk]

It should also be extended to blocks inside static and const items' expressions:

#![feature(const_fn)]

const X : usize = {
    let mut sum = 0;
    for i in 0..5 {
        sum += i;
    }
    sum
};

#[allow(unused_variables)]
fn main() {
    let a : [i32; X];
}