Goose  Timeline

• removed fmtlib, now use std::format
• vastly improved the overload resolution debugging tools
• prelude: started adding some extra error detection for small things that don't need to be builtin
• prelude: started working on implementing #for for tuples, some stuff needs to be addressed still
• fixed some type checking issue with wrapped args
• fixed superfluous nested lifetime scope in brace blocks (which caused redundant calls to some extension points)

• Implemented a test for variadic functions
• Fixed a million issues and missing things preventing the above from working
• Implemented equality operators for types

• Added a location id to all CIR instructions (needed with the stack based approach to locate intermediate results)
• Fixed a bunch of verifier errors
• Re-enabled most verifier tests, other than some requiring to re-implement a few more bits

• CIR instructions are now stored in lists
• Execute: handle the stack
• Converted some instructions to use the stack

• bracket blocks inlined in the code are no longer proposition lists but a new type of block to contain "ghost code" (ie a verification specific cfg)
• added a GhostBranch instruction to insert the above in the middle of regular code
• removed a bunch of hacks to ignore load/stores involving ghost funcs during execution and codegen since they are now separated from normal code using the above
• miscellaneous other refactorings and improvements
• as a result ghost code is now more flexible and can use idiomatic tuple assignments to exchange the values of two ghost function closures

• refactored the ref syntax again: "ref" is now an infix operator that takes an "AccessLevel" compile time value (mut/const/temp) on the lhs, or a TVar to capture/constrain it
• used the above feature to fix the constref verification _ConvertArg overload which was silently dereferencing the arg, causing it to get converted to a temp ref in all cases

• Refactored LocationId into a separate class and actually use it everywhere instead of uint32_t, this makes it easier to make generic wrappers for APIs
• g0 api: more work on the CIR api

• Started work on extensibility api
• some code cleanup

• Type predicates' identity and placeholder are now created immediately, rather than when parsing their content
• Added missing type predicates lazy parsing during typechecking
• Fixed a type checking rule falling back to unification, which is no longer needed

• Instead of falling back to unification as the default type checking rule, implemented default type checking rules similar to the default unification ones
• Fixed a nasty generator bug
• Fixed reference type parsing not generating a location
• Fixed where operator not generating a location that spanned both the types and the predicates
• Various fixes to accomodate random api changes in the latest llvm
• Updates fmt and catch2 versions

• Refactored and simplified the way integer and string constants are handled: we no longer try to resolve them during typechecking, this breaks when parametric types are involved and also it makes no sense, typechecking is about types, not values
• Fixed multiple places where locationIds weren't propagated
• Verifier: variable assignments now verify the destination variable type's refinement conditions
• Fixed a test where the above change detected a bug, kept the bugged version as a new verification failure test

Then fixed a MILLION horrible problems caused by all that. Now almost everything works again. *sobs* check-in: 9b058524b4 user: achavasse tags: trunk

• Added overloads to the comma operator to be able to construct tuples of references.
• Fixed reference typechecking rules so that overloads taking values directly have priority over overloads taking references.
• Fixed a template function expression parsing bug.

• Removed the poorly thought out "domain" system that was intended to allow for different implementations of functions for runtime and for compilation time, which was adding an absurd amount of crap everywhere and should be unnecessary with the current planned approach for implementing data structures.
• The using statement doesn't do lazy parsing anymore. Lazy parsing is better left to specific constructs that require them (such as function bodies and later on class/structs). This removes the only case of significant newline character in the language.

• Got rid of the gross system of performing unifications twice in all cases. It's only really needed when invoking template functions.
• Since the above had the unexpected side effect of fixing the tuple Initialize() overloads not being called, fixed those (which were actually broken).

• Implemented Initialize overloads for tuples.
• Lots of cleanup.