chore(ssa refactor): Implement function inlining

[jfecher]

Related issue(s)

Resolves #

Description

Summary of changes

Implements function inlining for the ssa refactoring. This pass will attempt to inline all functions into (a copy of) main. If it fails to inline all functions because a function in a function call is still unknown, it will keep each function in the Ssa struct and set the new main function to the partially-inlined version. If all functions are successfully inlined, the fully-inlined main function is the new main function and all other functions are removed.

Dependency additions / changes

Test additions / changes

Checklist

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt with default settings.
• I have linked this PR to the issue(s) that it resolves.
• I have reviewed the changes on GitHub, line by line.
• I have ensured all changes are covered in the description.

Documentation needs

• This PR requires documentation updates when merged.

Additional context

[jfecher]

Open questions:

1. Are the comments clear enough that you can more easily tell what is going on?
2. Not sure what kind of tests we should have. It seems they should be quite complicated to be useful. I've added a simple one to start out with.

[joss-aztec]

Not sure what kind of tests we should have. It seems they should be quite complicated to be useful. I've added a simple one to start out with.

Probably out of scope for this PR, but if tested in conjunction with constant folding and DCE, we could:

1. Take some program with no arguments, foreign functions, or other sources of uncertainty, such that it can be fully solved
2. Run inlining, constant folding and DCE to check that program reduces to a single instruction returning the expected constant

E.g. check that

add_3 {
  block0(u8 v0):
    v1: add v0 u8 3
    return v1
}

double_and_add_3 {
  block0(u8 v0):
    v1: mul v0 u8 2
    v2: call add_3 v1
    return v2
}

main {
  block0:
    v0: call double_and_add_3 u8 7
    v1: call double_and_add3 v0
    return v1
}

Reduces to

main {
  block0:
    return u8 37
}

I guess we'd also need other simplification passes if were we to test a program containing functions that compromise of more than a single block.