Allow parentheses `(..)` in expressions

[mohammadfawaz]

Example:

let x = 1 + (2 * 3);

[lethalgem]

@mohammadfawaz What should a parentheses be called?

Right now this is the test and result

check(
        &run_parser!(expr(), "1 + (2 * 3);"),
        expect_test::expect!["BinaryOp { op: Add, lhs: Immediate(Int(1)), rhs: Tuple([BinaryOp { op: Mul, lhs: Immediate(Int(2)), rhs: Immediate(Int(3)) }]) }"],
    );

Obviously, Tuple is incorrect. Do we just name it Paren? Is there a specific output for parentheses in expressions you're expecting?

[mohammadfawaz]

Obviously, Tuple is incorrect. Do we just name it Paren? Is there a specific output for parentheses in expressions you're expecting?

Right, yeah the parser should be careful what actually get prioritized here. I do imagine a expression enum variant called Parens which contains an expression.

[otrho]

The difference between a single element Tuple and a parenthesised expression is subtle. Most languages handle it by putting a comma after the field in the tuple, i.e., (123,).

[mohammadfawaz]

Yeah makes sense. So should we assume that something like (123) without a , is equivalent to just 123? For example, this does not compile in Rust:

fn main() {
    let x = (1,) + 2;
}

but this does:

fn main() {
    let x = (1) + 2;
}

This also works with a warning that says that the parentheses are unnecessary:

fn main() {
    let x:(u32) = 5;
}

[otrho]

Yep. This works though:

fn main() {
    let x = (1,).0 + 2;
}

[mohammadfawaz]

When #138 is merged, there will no longer be any ambiguities here.