Lower const parameters

[Veykril]

Currently const params are not lowered at all:
https://github.com/rust-analyzer/rust-analyzer/blob/aa91a0268bae6deda964a9fdfcbdbd2d8ca5802f/crates/hir_def/src/path/lower.rs#L177-L178

These kind of define bodies, so they come with all the goodies(and problems like local items) that other items like functions, statics and consts come with, and just like those they should ideally be lowered lazily.

See corresponding zulip discussion https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Fwg-rls-2.2E0/topic/ConstArg.20lowering

[dickytamara]

just reference

#![allow(non_upper_case_globals)]
pub const fn test(abc: i32, ffff: i32) -> [i32; 2] { [abc, ffff] }
fn test1(abc: i32, dcba: i32) -> [i32; 2] { [abc, dcba] }

static lookup: &'static [[i32;2]; 5] = &[
    test(0x0fab272b, 0x0fab272b), test(0x7e1d93ea, 0x7e1d93ea),
    test(0x0fab272b, 0x7e1d93ea), test(0x7e1d93ea, 0x0fab272b),
    test(0xabc, 0x000fffff) // <-- just reference
];

fn main() {
    //
    let lookup1:  [[i32;2]; 5] = [
    test1(0x0fab272b, 0x0fab272b), test1(0x7e1d93ea, 0x7e1d93ea),
    test1(0x0fab272b, 0x7e1d93ea), test1(0x7e1d93ea, 0x0fab272b),
    test1(0xabc, 0x0000dcba) // <-- just reference
    ];

    lookup.iter().for_each(|x| println!("{:?}", x));
    lookup1.iter().for_each(|x| println!("{:?}", x));

}

[HKalbasi]

If each constant needs a body for its own, locating them/allocating id for them will be hard. My suggestion is generalizing body to an expression store, and include expressions of constants in generics in the related definition's body. So for example:

fn foo<const N: usize = {2 + 2}>(x: Const<{2 + 2}>, y: Const<N>) -> Const<{2 + 2}> {
  let x: Const<{2 + 2}> = Const::<{2 + 2}>;
  x
}

all of 2 + 2 would get ExprId from function's body. Similarly, expressions inside const and static type annotations will be included inside of their bodies. And in this way, type alias will become a DefWithBody so it can lower and evaluate expressions. Body of a type alias has no meaningful root, so we may want to split Body into two abstractions, one with body_expr and params and one with the rest of fields (the expression allocator part).

Comments?

[flodiebold]

I think having a common expression store for all constants probably makes sense, but maybe not making that the body? How about we introduce something like an ExpressionStore and have Body contain one of those (basically what you're suggesting in the last sentence). So TypeAlias wouldn't be a DefWithBody.