type5 is much more first principles based, so we get a lot
of weird quirks removed:
- FromLiteral no longer needs to understand AST
- Type unifications works more like Haskell
- Function types are just ordinary types, saving a lot of
manual busywork
and more.
Previously, it was hardcoded at 'compile' time (in as much
Python has that). This would make it more difficult to add
stuff to it. Also, in a lot of places we made assumptions
about prelude instead of checking properly.
By default, we add a lot of build in functions that may
never get called.
This commit adds a simple reachability graph algorithm
to remove functions that can't be called from outside.
Also, unmarks a lot of functions as being exported. It
was the default to export - now it's the default to not
export.
Also, some general cleanup to the wasm statement calls.
Now both dynamic and static arrays can be fully fold'ed.
Also adds support for type classes that have a function
argument.
Also, various usability improvements to WasmGenerator.
Also, integration tests now don't dump their stuff without
VERBOSE=1, this speeds up the tests suite by a factor of 9.
Also, tests can now set with_traces to add a number of
tracing functions for help debugging your code.
This also removes the InternalPassAsPointer experiment.
This also fixes that u8 values were stores as 32 bits
in structs and tuples (but not dynamic arrays since that
is special cased as bytes).
Also, fixes allocation issue wi th dynamic arrays, it
would allocate quadratic amount of memory.
bytes continues to be the preferred name for u8[...].
Also, putting bytes values into the VM and taking them
out still uses Python bytes values.
This also lets used use the len function on them, for
whatever that's worth.
Foldable take a TypeConstructor. The first argument must be a
NatNum.
The FunctionSignatureRouter wasn't completely on point, instead
this commit adds an TypeClassArgsRouter lookup router. This
makes sense since the only available arguments we have to find
a router is the list of type class arguments.
Before this commit, finding the implementation for a type
class method was done with a simple lookup table.
This commit adds a router based on function signature.
This also paves the way for adding type constructor
arguments in function signatures.
And it removes quite a few references to the prelude out
of the compiler.
Also adds a bunch of helper methods to render signatures
as strings.
By annotating types with the constructor application
that was used to create them.
Later on we can use the router to replace compiler's
INSTANCES or for user defined types.
A lot of isinstance checks no longer did anything, since
the referred to variable was always a type.
In some places, we used it to check if a type was internal,
it's unclear if we will need to rebuild those checks in
the future.
Before, a type class was a property of a type.
But that doesn't make any sense for multi parameter
type classes.
Had to make a hacky way for type classes with
type constructors.
They look a lot like placeholders, but they exist before
the typing system takes place. And there's a (much smaller)
context to deal with.
For now, removes Placeholders in user function definitions
as they were not implemented.
Adds signature to function to try to get them closer to
type class methods. Already seeing some benefit in the
constraint generator.
Stricter zipping for safety.
Also extended the hack around u8 to u32 cast used
in crc32 - its type was lost, so it would just cast
to whatever the environment was expecting.
Had to do_format_check=False since the file has
some comments and such.
Various updates to bring the project uptodate.
- Updated required packages
- Removed runtimes that are not being updated
- wasmtime is for now the only supported runtime
- Implements imports for wasmtime runtime
- Fixes a memory access bug for wasmtime runtime
- compile_wasm is now optional - runtimes have to
implement and call this themselves
- Typing fixes
- Linting fixes
Prior to this PR, each type would have its own handwritten
test suite. The end result was that not all types were tested
for all situations.
This PR adds a framework based on a Markdown file, which
generates the basic tests for the types defined in json
files. These are auto generated and updated by the Makefile
before the test suite is run.
Also, a number of unsupported type combinations are now
supported.
Also, we now support negative literals.
Also, allocation calculation fixes for nested types.
Also, the test helpers can now properly import and export
typed variables such as bytes, static arrays and tuples. This
may come in handy when it comes to phasm platform wanting to
route data.
Also, adds better support for i8 type.
Also, started on a runtime.py, since there's quite some code
now that deals with compile time handling of WebAssembly stuff.
Also, minor improvement to the type constrains, namely we
better match 'tuple' literals with static array types.
Also, reduced spam when printing the type analysis results;
constraints that go back on the backlog are now no longer
printed one by one. It now also prints the end results of
the typing analysis.
Also, reorganized the big test_primitives test into type
classes.
Also, replaced pylint with ruff.
Also:
- Started on SIMD before finding out no implementation
supports that yet
- Type fix result Import / Function
- Various error reporting improvements
- Non-const tuple members
