Expected type during value synthesis

[kaleidawave]

Currently the mapper functions a parameter is synthesised as generic

declare const array1: Array<number>;
array1.map(function mapper(a) { return a + 2 })

then the function is checked based on the restriction.

A better way would be to synthesise the function with the knowledge/expectation that it is expected to be a function as number => U. This means that the new_function can then create parameter restrictions eagerly.

This could be considered as traditional type inference

[kaleidawave]

Added the parameter-argument part with

ezno/checker/src/types/calling.rs

Lines 53 to 98 in 1aa77e2

	let base_function = get_constraint(ty, &checking_data.types).unwrap_or(ty);
	// TODO fails for ors
	// TODO not great, gets parameters here, then
	let arguments = if let Type::Function(f, _) | Type::FunctionReference(f) =
	checking_data.types.get_type_by_id(base_function)
	{
	// TODO clone here bad
	let parameters = checking_data.types.get_function_from_id(*f).parameters.clone();
	arguments
	.into_iter()
	.enumerate()
	.map(|(idx, argument)| {
	let expected = parameters.parameters.get(idx).map_or(TypeId::ANY_TYPE, |p| {
	get_constraint(p.ty, &checking_data.types).unwrap_or(p.ty)
	});
	SynthesisedArgument {
	spread: argument.spread,
	position: A::expression_position(argument.expression)
	.with_source(environment.get_source()),
	value: A::synthesise_expression(
	argument.expression,
	expected,
	environment,
	checking_data,
	),
	}
	})
	.collect()
	} else {
	arguments
	.into_iter()
	.map(|argument| SynthesisedArgument {
	spread: argument.spread,
	position: A::expression_position(argument.expression)
	.with_source(environment.get_source()),
	value: A::synthesise_expression(
	argument.expression,
	TypeId::ANY_TYPE,
	environment,
	checking_data,
	),
	})
	.collect()
	};

Not great position + overhead of clone. But works ATM

These work though

from