Add ability to reference part of a word-sized constant in push instructions

[PhilippGackstatter]

Add ability to reference part of a word-sized constant (in this context created with the mechanism from #2011) in push instructions, e.g.:

# see issue 2011
const.METADATA_SLOT_NAME="miden::basic_fungible_faucet::metadata"

begin
    # push the first two elements of the word onto the stack
    push.METADATA_SLOT_NAME[0..2]
end

Context: 0xMiden/miden-base#1394 (reply in thread)

[Fumuran]

I've been thinking about this task, and it seems to me that it will require quite a lot of changes. Essentially this issue requires the support of arrays in assembly code, since a slice of a word is an array. So first we have to have something like this:

const.EXAMPLE_ARRAY=[1, 2, 3, 4, 5, 6, 7]

begin
    push.EXAMPLE_ARRAY
    # which will be equal to 
    push.1.2.3.4.5.6.7
end

After having the plain arrays, we could add a slicing feature for them. It could work in a similar way to how we resolve constant expressions in the analyze() function in the assembly-syntax/src/sema/mod: slice of an array should result in some other array. This will in fact solve this issue, but only if we remove the IntValue::Word in favor of array consisting of 4 elements. Otherwise we will have to adapt the slicing for the IntValue::Word but it should be much easier since it will result in an array anyway.

[bobbinth]

I was thinking that the scope of this issue would be much less limited. We already have word-sized constants, and so we don't need to introduce a more general array type or enable manipulations of arrays/slices. So, what we need is:

const.WORD=[1, 2, 3, 4] # this already works

begin
    push.WORD # this already works

    push.WORD[0..2] # this would be translated to push.1.2, which also already works
end

So, really what we need is just a transformation this new syntax to already existing syntax - though, how difficult this is, I'm not sure.

[bitwalker]

As @bobbinth noted, we only support felt or word-sized constants with push, and supporting specific slicing syntax for push.CONST is narrow enough to be a simple task.

No transformation is needed here - we'd just add a new ConstantExpr variant for slices, and then at expansion time validate that the constant being sliced is a word (or aggregate of felts, but I think we should be stricter initially).

One change I plan to make soon is to defer constant expansion/propagation until assembly-time, so that the AST retains more of the original source information (right now all uses of constants are rewritten to their literal values, so we lose the fact that push.0.1.2.3 was originally written push.WORD. But the impact here would still be relatively minimal, since the way we expand constants during semantic analysis vs during assembly would be virtually identical.