Support calling generic methods

[degory]

Generic methods are quite common in the .NET libraries, and not being able to call them renders significant useful functionality inaccessible to ghūl code - it should be possible to call these methods.

Providing support for explicit actual type arguments when calling generic functions is a bit awkward because ghūl generic type expressions cannot be parsed from an expression context without either some syntax to introduce the type expression (e.g. as in new or cast) or else adding more sophisticated backtracking to the parser.

However, it actually looks relatively simple to infer correct types for generic type arguments (at least whilst we don't yet have type inference for anonymous functions see #497 #498)

The process is:

• Attempt to pattern match the shape of each of the function's actual argument types to the function's formal argument types, treating the function's formal generic type arguments as wild cards, and binding types that match: so a formal function argument of type Iterable[T] ref matches an actual function argument type of Iterable[int[]] ref, binding actual type int[] to type variable T
• If we can't match every actual argument's type to the corresponding formal argument, then assign the overload a no-match score
• Where a formal type argument appears multiple times in a function's signature, the actual generic parameter type bound is the most derived common ancestor type of all matches across all actual arguments.
• If the most derived common ancestor type is object then assign a low match score for that argument
• Check all type constraints are met - i.e. the actual argument is assignable to or from the constraint type depending on direction of variance - if any type constraint isn't met then assign that function argument a no-match score
• To emit correct IL assembler we need to refer to any types in the method signature via !!N positional notation