Copied from implementation based on old machine,
with new Transformer and minor changes.

Also, collect all used datatypes over program

since all locals are positional in machine, we can just use those
positions as register numbers.

Removes the now unnecessary `RegisterAllocation` analysis on JIT code

Generate information on the used datatypes (which alternatives there
are, with how many fields of what types) into the output for the JIT.

* the main statement is run in an empty environment
* `BlockLabel` does not need to be a `Tree`

Allows easier extension with more register types and handling of registers

Clauses describe the values closed over explicitly,
passed parameters are implicit.
This is now reflected in the name.

The Environment describes the variables currently in scope.
The FrameDescriptor describes merely their numbers (i.e. how many
registers are needed).

There are two ways a clause may be compiled:
As a "closure": only free variables of the clause are copied over, a
new frame is generated.

"inlined": All variables in the current environment survive,
the enclosing frame is extended to leave enough space for the new locals.

For now. Later, maybe add additional Bool registers.

The substitutions generated in machine do not necessarily list all
live variables

Make the frame big enough to fit locals of inline clause

Now also using `transformInline` for consistency

Leave this to the jit executable, which has the frame sizes

we can now run programs using the JIT backend with
`--backend jit --lib libraries/jit <source file>`.

This adds the 5.7M executable to the repository for now.
In the future, we should find a different solution to this.

* Use numbered register for output of Let
* Use `ListMap`s in `PrettyPrinter` (preserve order)

Implement SWITCH for Unit

This is a first step, reusing registers when choosing the names
of the parameters of clauses transformed inline.
Registers are reused if they are not free in the clause.

Currently just throwing an error

* `Let` would not get a new register for the result
* `Switch` would reuse registers, which is not possible with the
  current semantics of the `Match` instruction

Drop/Mov/Swap

* Use maps of old registers to new ones, making the check if a
  register value is still needed easier (using `contains` now)
* Simplify code by moving `todo`-list generation into the loop over
  register types

Currently, this has to be done manually and requires either a GH_TOKEN
environment variable or running `gh auth login` first.

Binaries have been renamed to `rpyeffect-jit-$(uname -m)-$(uname -s)`

This corresponds to commit ae72574 in the jitting-effects repo.

For forward references, generate a mapping directly

JIT backend: Add sbt target to download jit binary

Merging although CI does not work yet due to missing token

Search for the JIT binary in the following places:
1. specified as part of the settings arg `--jit-binary`
2. specified in environment variable `EFFEKT_JIT_BIN`
3. in `./bin/${platform}/rpyeffect-jit` relative to PWD
4. in `./bin/${platform}/rpyeffect-jit` relative to the jar

Currently broken

`String` support for JIT

To be consistent with the other backends (e.g. llvm)

To be more consistent with other backends (e.g. llvm, chez)

JIT: Directory and package structure

- Use the correct names without spurious builtin effects for primitives
- Un-ignore tests with Boolean `==`