Current state:
LabVIEW FPGA has a great feature that can resolve and display the size of fixed-size arrays at edit-time. This size inference happens especially at the output of array functions and at the output of auto-indexing tunnels of For Loops.
Example:

➡️ Notice how the array functions have numeric constants for their size / length / index parameters.
➡️ Notice how the For Loop has a numeric constant for its Loop Count parameter.
For better understanding, we will further call these Size / Length / Index / Loop Count parameters the "SLIC" parameters.
Limitations:
The edit-time size inference is currently limited to simple cases where the SLIC parameters are numeric constants.
If these parameters are something more complex, the output array loses its fixed-size type and appears as a variable-sized array instead.
Idea:
Improve size inference by allowing SLIC parameters to be more than just numeric constants, such that the output array is still resolved as a fixed-size array at edit-time. We could have several levels of improvement:
Level 0 (current state): SLIC parameters can only be numeric constants:

Level 1: SLIC parameters can also be the size of another fixed-size array:

Level 2: SLIC parameters can also be the result of a single math operation from the following list: Add, Subtract, Multiply, Quotient & Remainder, Increment, Decrement, with its inputs being either numeric constants or the size of another fixed-size array:

Level 3: SLIC parameters can be any expression that the editor can constant fold, similarly to what already exists for desktop applications:

➡️ Notice how input "Fixed-Size Array" itself is not constant folded since its values are unknown, only the array size is constant folded.
Level 4: SLIC parameters constant folding can pass through inputs/outputs of an inline VI:

Motivations:
This feature would improve the FPGA coding experience by allowing more complex scenarios with arrays, while still having the feedback of their sizes in the Context Help. Also, it would open new possibilities with malleable VIs that can use the fixed size of arrays as a type specialization.
I hope this makes sense!
Regards,
Raphaël.