TODO

## Short term
Fix optimizer-unsafe potentially non-constant-time processing of struct comparison.
Use concrete type constraints on variable assignments rather than "if false" type hints.
In the bootstrap version of Rune, add support for autocasting return expressions
    to the type of other return expressions
Add an option for generating SoA vs AoS memory layout so folks can do their own benchmarking.
Write a C or C++ backend code generator for improved debugging of Rune, and so folks can benchmark with
    full front-end optimization of different C compilers for benchmarking.
Enhance gdb pretty printer so that we don't have to generate show methods.
Figure out when relationship transformers should run.  Right now it is in the order statements are bound so that module-level variables can be passed into the transformers, but we assume all transformers are run before binding a constructor, which is currently false.  Figure out the right thing and do it.
Use concrete type constraints in binding.  This can help eliminate problems
    in binding recursive functions, and also non-template classes.
Don't allow generated fields to be written outside of generated code.
Add an Object class that matches all types, so we can have case (Object, Object, Object).
Defend vs Spectre/Meltdown: duplicate bignum functions in runtime to have constant-time vs
    non-constant time APIs.  Do not pass in a secret bit.
Figure out how to programatically manipulate labels in transformers.
Flesh out index overloading: write is not yet supported.
Support Overloading method get/set methods.
Improve safe mode:
    Throw error when destroying an object that has a reference on the stack.
    Use overflow/underflow intrinsics in LLVM.
Fix LLVM select for case when select bit is secret.
    Also, only evaluate one or the other when select is not secret.
Add syntax for declaring volatile globals at specified addresses, so we can do memory-mapped I/O.  Consider using a global io array.
Add good support for interop with C++, which is a key requirement for a language to replace C++ in prod:
    syntax for declaring extern "C++" functions, and deal with name mangling.
    Add support for calling C++ constructors and methods.
    Add support for c++ unique pointers, which are often returned.
Add support for C pointer types, which can be returned by C functions declared extern "C".
Add "unsafe" blocks where it is legal to dereference or index into a C pointer.
Write all the Benchmark Games benchmarks twice: one single threaded and
    honest, one multi-threaded and using similar tricks used by the others to win.
Implement dynamic class extensions.
Implement inheritance via composition, using exclusive relationships.
Return error codes for each deError call, which error tests can expect.
Write initial language reference manual.
Add LLVM compiler hints and optmizations as described at
    https://llvm.org/docs/Frontend/PerformanceTips.html#adding-to-this-document.
Support named parameters, like Python.

## Medium Term
Support negative indicies, like Python, in slices to indicate size relative to length of the array.
Write tests to verify that constant time processing of secrets is achieved.  E.g. if (issecret(foo)...
Add support for fixed-sized arrays for improved speed.
Make modular inverse constant time.
Upgrade from lineNum to an object specifying the text of the line, position, and file name.
Switch to BoringSSL crypto primitives for faster constant-time bignums, as well as variable-time bignums.
Perform constant propagation.
Enforce private access to non-extern identifiers from other packages.
Support full co-routines in iterators in the LLVM backend.
Support tuple unpacking.
Support overloading modular operations, so we can support modular polynomials, etc.
Add multi-threading support.
Add schema-level reuse statements.
Write a schema generator for Rune similar to the dataview program for DataDraw schemas.
Flush out transformers's Rune code interpreter.
Finish transition to memory pools, and allocation of global arrays with mmap of the memory available on the machine so large arrays never move.
Add support for 32-bit mode.

## Long term
Rewrite Rune in Rune.
Support lambda expressions with Function(statementExpression) constructor.

## Optimizations
Tune floating point operations: For some reason, clang is running C/C++ floating point at about 2X our speed.
Rewrite heap to be more efficient for small passed-by-value objects like i32's.  The back-pointer and
  index are not needed for heaps of values.
Save memory on 32-bit targets using 32-bit lengths.
LLVM: generate switch rather than a chain of branches.
Support tail recursion.
Use existing uint32 or int32 field for nextFree to save memory for non-ref-counted classes.
Identify fields that are always accessed together and merge them into tuples.
  Generate array-of-structures for these tuples.
Support unions, like DataDraw, where the field is selected by an enumerated type.