Inline calls to constant functions and evaluate them at compile time

Originally posted by @nazar-pc in #300

The basic problem right now is that calls into const fn are not inlined recursively. Here is an example:

const K: u8 = 20;
const PARAM_EXT: u8 = 6;

const fn y_size_bits(k: u8) -> u32 {
    k as u32 + PARAM_EXT as u32
}

const fn metadata_size_bits(k: u8, table_number: u8) -> u32 {
    k as u32
        * match table_number {
            1 => 1,
            2 => 2,
            3 | 4 => 4,
            5 => 3,
            6 => 2,
            7 => 0,
            _ => unreachable!(),
        }
}

fn compute_fn_impl<const PARENT_TABLE_NUMBER: u8>(
) -> u32 {
    let parent_metadata_bits = metadata_size_bits(K, PARENT_TABLE_NUMBER);

    let num_bytes_with_data = (y_size_bits(K) + parent_metadata_bits * 2).div_ceil(u8::BITS);

    // ..
}

Right now this requires Int8 capability:

  error: Missing required capabilities for types
    |
    = note: `u8` type used without `OpCapability Int8`

Even though the exact value of num_bytes_with_data is known at compile time for every instantiation of the function and no u8 should actually exist anywhere in runtime. Some workarounds exist:

• let parent_metadata_bits = const { metadata_size_bits(K, PARENT_TABLE_NUMBER) };
  

  This helps with the first variable, but doesn't scale further.
• Making ^ a proper constant doesn't work due to "error[E0401]: can’t use generic parameters from outer function" error

The only real solution is to inline everything recursively manually and wrap with const {}, which hurts code readability a lot, but perhaps this is something compiler can do as a workaround without redesigning too many of things.

In the end, I expect that all constants, variables and const fn calls to be inlined into a single constant value at compile time automatically, including any possible integer casts (like u8 -> u32), which for constant values are also known at compile time.

Empieza reproduciendo el ejemplo de Rust y su error por la falta de capacidad Int8 en el compilador o en el pipeline de generación de código. Traza cómo se transforman las llamadas a const fn, las instanciaciones genéricas, los casts y las expresiones constantes, y verifica después que el ejemplo compila sin valores u8 en tiempo de ejecución ni una capacidad Int8.