Add basic narrowing

[kaleidawave]

Adds narrowing of variable reference types based on JavaScript equality constructs.

Currently adds the following

• === narrowing
• typeof narrowing
• Support for && and ||
• De Morgans's law edge cases
• assert *value* is *type* checking
• Some number extras which require additions from Basic operator checking #186
• (X | Y).tag === ...
• *key* in obj case removal and creation
• instanceof

Support across variable declarations and functions thanks to more dependent types

Additionally the LocalInformation merging now handles final events better. (see new control flow test, which would previously be 3 | 7) AND AnonomousObjectLiteral stores the properties on the type

[kaleidawave]

@danvk thought you might find this interesting! I watched the Michigan TypeScript video and read your blog post on implementing inferred type predicates. (congrats on getting it merged, it is a great feature!)

In Ezno it was a lot easier to add narrowing with its more dependent type system. In Ezno the expression typeof x === "number" has a type like EqOperator<TypeOfOperator<typeof x>, "number"> which makes getting the information for narrowing pretty simple (you can sort of see that in the lines above). So Ezno has something closer to your original intuition rather than the TSC flow node control flow structure.

One of the interesting parts was "Pathological Cases and an Insight" with this case edge case in the else

function flakyIsStringRewrite(x: string | null) {
  if (typeof x === 'string' && Math.random() > 0.5) {
    x; // type is string
  } else {
    x; // type is string | null
  }
}

this helped me fix a bug in my implementation. For else branches I run get_narrowed_values(condition, true), where true negates the condition in the if. If I have the && expression above with negate = true it then means that it applies one of the De Morgans law. So it now treats !(a && b) in the code as !a || !b and it only adds a narrow if both sides have a condition for the same variable (=on here) (the zipping code being for (on, lhs_request) in lhs_requests { if let Some(rhs_request) = rhs_requests.get(&on) { ...).

I think I have got this covered in the tests here

Don't know if there is an equivalent section in the TS narrowing logic but thought my intuition thinking about De Morgan's laws and generating A | B only if both sides of an || condition give narrowed values for the variable was a nice way to handle this case.

[kaleidawave]

Most definitely missing some functionality but the basics are in so merging 🎉