Improvements to properties + intrinsic types

[kaleidawave]

300 passing 🎉

• Replace todo! under /synthesis for fixes or unimplemented error (for Add fuzz target checker/fuzz/check_project_naive #152)

• Under option (true by default): if for (let i = 0; ...) or similar where the initialiser is number like. Assume i has constraint of number (assigning to any other type is not an advisable pattern). Assuming this constraint would skip work that will be done when Inferred generic (poly type) constraints #35 is added!

• Added TSC intrinsic string types

• TSC Uppercase, Lowercase intrinsic string types

• Added TSC NoInfer

• Ezno CaseInsenstive

• Added some WIP Ezno intrinsic number types

• Added some WIP Not type and Exclusive type

• Added new slice subtyping mechanism

• Have got the mapped property key of mapped types partially working.

  • Including modifiers
  • GenericChain::Mapped
  • Access is pretty good
  • Subtyping is still a bit WIP

• Have got delete checking in

  • No test for doing inside of function
  • Breaks the pop synthesis, so removing for now
  • As effect broken :(

• in is handled a bit better across functions

  • Getting pinned down to decidable is quite difficult

• Understanding break works

  • Turns out that was being run unknown as was trying to run 460 events on top level (default limit is 300)
  • Got it down to 360 by not queueing some SetVariables where it is in the scope up during application
  • And further down by changing the values in the test
  • However now the break isn't being fired. Might be to do with the carry, might not be ?

• Delete as effect

• Object.defineProperty and Object.getOwnPropertyDescriptor (constant functions)

  • PropertyValue::Configured
    • Might be bad for performance for a.push but oh well

• Sorting for numerical properties

• Sorting for later assignments (removed old weird .reverse thing)

• Proxy

  • Added get and set for Proxy
  • Added basic subtyping for Proxy (probably doesn't work in more general cases)

• Added Object.assign

• Added configurable checks (change + delete)

• Array.prototype.map

• Register as effect

• Merge definition hoisting into regular hoisting

• Cyclic alias (+ improved cycle detection and checking here)

StringBuild test seems a bit temperamental :/

[kaleidawave]

259 🎉

Going to remove some WIP things (operator checks, failing events, .d.ts emit) and split in to separate PRs. Also the template literal strings array needs changing (but should do that in the parser first , could do in #173)

Before merging

• Fix .map not calling error?
  • Also computed generics not working here
• Have a look at mapped type issues (Including the new GenericChainLink variant)

[kaleidawave]

269 🎉

failures:
    specification::collections::array_map
    specification::forward_inference::computed_generics_from_collection
    specification::staging::calling_type::array_slice_matching_pattern
    specification::staging::calling_type::properties_on_big_or
    specification::staging::calling_type::regexp_patterns
    specification::staging::exceptions_and_try_catch_finally::throw_through_internal_callback
    specification::staging::extras::exclusive
    specification::staging::mapped_types::as_rewrite
    specification::staging::mapped_types::negated_optionality
    specification::staging::mapped_types::negated_readonly
    specification::staging::mapped_types::optional
    specification::staging::mapped_types::specialisation

test result: FAILED. 269 passed; 12 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.05s

Hopefully can fix .map and make some progress on the others 🙏

[kaleidawave]

For mapped types: the last thing to fix is subtyping based on the mapped type being on the left. The problem to solve is indexing a type based on a type key. This sort of works ATM for Array[number] but not much more. I have just added support for reading on ty["a" | "b"] eagerly in get_property_unbound via splitting the branch and building a Logical::Or.

For more complex types: There exists Logical::BasedOnKey for a value based on the RHS key. I think this should be extended to somehow RHS. Somehow the value should be based off get_properties with a filter?

Aside: this is duplicate of lookup generics get_key_on...? Will come back to this maybe with default generics, or covariant lookup.

Ahh its all really complicated and making this PR take a long time. But when it is done :chefskiss:

---

Once that works then will have the proper foundations for .map (which uses properties)

[kaleidawave]

Getting there on mapped types checking (access is 90% done). The real problem is indexing the RHS type (right_ty) with a mapped generic. Lots of complex behaviour there which isn't easily implemented by my general process which is just to start on it and find out. But as it turns out there have been a few problems to my initial attempts:

• Walking properties on right_ty and backwards checking can cause things required on the left to be missed
• Scanning the property type works if the main property is a mapped generic. Otherwise not, so needs some work

Need to break the pen and paper for this one 🤔

This PR won't implement #179

[kaleidawave]

300 🎉