Infer function expressions in matching contexts

[dcodeIO]

This PR

1. legalizes omitting types on function expressions within function type contexts and
2. legalizes omitting any number of arguments

As an example, the test looks like this:

function testOmitted(fn: (a: i32, b: i32) => i32): i32 {
  return fn(1, 2);
}
assert(testOmitted((a, b) => a + b) == 3);
assert(testOmitted(a => a) == 1);
assert(testOmitted(() => 42) == 42);

function testOmittedReturn1(): (a: i32, b: i32) => i32 {
  return (a, b) => a + b;
}
function testOmittedReturn2(): (a: i32, b: i32) => i32 {
  return a => a;
}
function testOmittedReturn3(): (a: i32, b: i32) => i32 {
  return () => 42
}
assert(testOmittedReturn1()(1, 2) == 3);
assert(testOmittedReturn2()(1, 2) == 1);
assert(testOmittedReturn3()(1, 2) == 42);

fixes #449

[dcodeIO]

One remaining question is whether we should more strictly check the signature, i.e. changing

map<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U): Array<U>

etc. into

map<U>(callbackfn: (value: T, index?: i32, array?: Array<T>) => U): Array<U>

etc. and, in this example, requireing at least one parameter to be present, even though, technically, any number of parameters less than max works as long as the return type matches. Wdyt?

[MaxGraey]

Hmm, I don't think this make sense. Usually all params in signatures like that should be always optional by default. So additional mark ? manually is unnecessary work I guess. This not present in ts declarations and this not present in other languages

[dcodeIO]

Right, looks like the only place where the signature actually matters is where it is actually called (here: fn() inside of map). Let's do it the TS way then.

[MaxGraey]

fully optional map's callback signature also possible in real scenario: arr.map(() => 0) (just got zero filled array with same length of arr)