Constructor calls with generic type argument don't parse correctly

[kaleidawave]

Given

const y = new Y<3>(3);

It parses as something like:

expression: ConstructorCall {
    constructor: FunctionCall {
        function: VariableReference(
            "Y",
            1003..1004,
        ),
        type_arguments: Some(
            [
                NumberLiteral(
                    Number(
                        3.0,
                    ),
                    1005..1006,
                ),
            ],
        ),
        arguments: [
            Standard(
                NumberLiteral(
                    Number(
                        3.0,
                    ),
                    1008..1009,
                ),
            ),
        ],
        is_optional: false,
        position: 1003..1010,
    },
    type_arguments: None,
    arguments: None,
    position: 999..1010,
},

Something around here (or possibly return precedence) is broken when type arguments show up

ezno/parser/src/expressions/mod.rs

Lines 471 to 507 in e69e2c5

	let constructor_expression = Self::from_reader_with_precedence(
	reader,
	state,
	options,
	FUNCTION_CALL_PRECEDENCE,
	Some(start),
	)?;
	let position = start.union(constructor_expression.get_position());
	let (type_arguments, end) = if reader
	.conditional_next(|token| *token == TSXToken::OpenChevron)
	.is_some()
	{
	let (generic_arguments, _, end_pos) =
	parse_bracketed(reader, state, options, None, TSXToken::CloseChevron)?;
	(Some(generic_arguments), end_pos)
	} else {
	(None, TokenEnd::new(position.end))
	};
	let (arguments, end) = if reader
	.conditional_next(|token| *token == TSXToken::OpenParentheses)
	.is_some()
	{
	parse_bracketed(reader, state, options, None, TSXToken::CloseParentheses)
	.map(|(args, _, end)| (Some(args), end))?
	} else {
	// TODO are type arguments not allowed...?
	(None, end)
	};
	Expression::ConstructorCall {
	constructor: constructor_expression.into(),
	type_arguments,
	arguments,
	position: start.union(end),
	}