[DEMO] Compiler Optimization

[DBooots]

Demo only at this time

This PR adds an optimization stage to the compiler. This stage converts the Opcodes into a three address code interim representation, upon which various optimizing passes are performed. The interim representation is then converted back into opcodes and emitted to the program context as normal.
The optimizing passes currently implemented trim opcodes without changing any control flow, except to remove branches that are shown to be inaccessible.

Currently Implemented Passes

Suffix Replacement
Replaces CONSTANT: fields with the constant value, and replaces aliased SHIP: fields with the direct alias. This saves 1 opcode per ship alias replaced, and allows constant folding of the CONSTANT values.
Constant Propagation
Where a variable is assigned a constant, it replaces accesses of that variable with the constant (cognizant of global variables and triggers messing with variable values). This allows constant folding of the assigned values.
Constant Folding
Performs arithmetic, including scalar math functions, to reduce formulas to their simplest form. This includes the CONSTANT: fields from Suffix Replacement and the propagated constant variables from Constant Propagation. This step saves between 1 and 3 opcodes for every folding optimization that is performed.
Dead Code Elimination
Eliminates any branches where the condition is known to be false after propagating and folding constants.
Peephole Optimizations
This pass does a number of small optimizations:

• Replaces string indexing against a lexicon with suffix accessing, when the string is a valid identifier. This saves 1 opcode for every index set or get.
• Replaces parameterless suffix calls with a direct suffix access (since the suffix get opcode checks if it's a method and invokes it for free). This saves 2 opcodes for each suffix method call, but feels like cheating.
• Replaces calls to VectorDotProduct() with a simple multiplication opcode. This saves 2 opcodes for every VectorDotProduct() that is performed.
• Replaces double negation or double logical not operations with the original value. This probably doesn't come up often, but it saves 2 opcodes every time.
• Replaces not->branch[true|false] with branch[false|true]. This saves 1 opcode every branch simplified.
• Performs algebraic simplification (not necessarily of constants) to reduce the number of opcodes. E.g. A*B+A*C=A*(B+C), X*X*X = X^3, or -A+B = B-A . This saves multiple opcodes wherever possible.

Scope Simplification
Any scope that does not define any variables is eliminated. This saves 2 opcodes for each scope that is collapsed.

Next Steps

• More testing! While I've added some unit tests, which run correctly, and I've reviewed the opcode output from those tests to see that the optimization passes are doing what they are supposed to, unit testing only covers simple cases. I need to compile larger and more complicated programs and see what breaks.
• Further optimization passes. The OptimizationLevel.cs file includes the roadmap for future passes that could be implemented. So far only the O1 (Minimal) level is finished.
• Adding optimization level specification to the compile function. Unit testing has direct access to the Compile Options fed to the compiler. We'll need to add support for in-game compilation level selection. I think I've got it hardcoded to use no optimizations in the interpreter (prioritizing responsivity over performance) and Minimal for general compilation (running or compiling programs), but this is only a development hack.