Cheeky  Timeline

[20_minutes_in_and_out_adventure.jpg]

• Added tests for, and fixed compile time if
• Added a "WrappedValue" type, considered a high penalty generic match to pass around "any comptime value" because the old way to do this was breaking the type system (implementing compile time if somehow exposed this issue)
• Cleaned up the way builtin function calls are handled (to solve an issue exposed when implementing WrappedValue)
• Fixed the way return values are type checked (to solve an issue exposed when refactoring the builtin function calls)

• get_call_rule: cache and reuse the call rule found for the callee
• call_rule: add a method to get all possible return types from the callee

• Added missing context guards when trying multiple signature branches and between candidate typechecking rules
• Added proper typechecking rules error handling for cases that are clearly wrong and shouldn't fall back to the next best rule (which accidentally "worked" because of the above)
• Removed the hackish "coercing a fresh identifier against something yields an error" coercion rules, instead fixed the comptime builder that incorrectly discarded values that were already comptime constants
• Fixed declaring anonymous functions
• Added code to dump the IR (cfg) of a function
• Added a test for (and fixed) var declarations

• Added "Borrow" and "Release" Ir instructions, emitted when coercing a ref into a borrow
• Added a system to push "cleanup" ir code generation to emit cleanup instructions after a call (for example borrow then release)
• Implemented builtin intrinsic functions
• Implemented assignment operator
• Implemented coercion of var to mutable ref

• added #as_param() to transform function parameter declarations
• convert reference parameters to borrow parameters

• ir, interpreter: added address manipulation and storage instructions
• very first version of local variable declaration (untested)

• Fixed func decl versus call precedence
• Added tests for argument type function polymorphism
• Factored some testing boilerplate and reorganized test files

• Fixed parsing issue with implicit return values
• Fixed incorrect return value type when coercing StagedCalls to regular and builtin functions
• Fixed wrong handling of return values in the interpreter
• Added a test for function return values
• Added a way to log the content of a cfg and display it in the log viewer

• Make Index<Location> default initialization return the current location, rather than a nil location
• Make Index<Value> carry an Index<Location> to keep track of where values are referenced from (and not only where they are defined at)

• Invalidate the resolver cache whenever a scope is pushed or popped (so that for instance the next token looked ahead after a comptime expression gets resolved again in the proper scope)
• Directly take Sequences in the env api instead of sequence values
• Fix the construction of function identities and the identity under which polymorphic functions are bound
• Properly diagnose undefined identifiers used as part of an expression
• Actually use anonymous holes instead of holes with empty strings as name

• Add missing Param wrappers when generating function types
• Calling functions with parameters now works (the parameters themselves don't but one thing at a time)

• Fix GenericStagedCall definition
• Fix coerce() to use the same ranking as polymorphic_func's try_resolve_macro_call (since non macro overload call resolution are now done through coerce())
• Overload commit_value for StagedCall that triggers type resolution for the entire expression tree and detects and complains about failed resolutions
• Added a test for invalid function call diagnostics

• Improved logging
• Implemented filtering in log_viewer
• Diagnose undefined identifiers