Function declaration, expressed in rizz code like `fn foo(Char: bar) -> Int {}`.

A FunctionDecl's rizz grammar in-code is as follow, in the given order:

• A leading Fn.
• Function's name as an Identifier.
• Function's optional parameters enclosed in OpenRBracket and CloseRBracket expressed as ParmVarDeclExpr (both round brackets are still required even if no arguments are provided to the function).
• Function's optional return type. If the function does returns, the return type is expressed as an Arrow Token and a BuiltinType.
• Function's body within a CompoundStmt.

Function parameter, expressed in rizz code like `Bool: baz`.

A ParmVarDecl's rizz grammar in-code is as follow, in the given order:

• The parameter's type as a BuiltinType.
• A Colon.
• The parameter's name as an Identifier.
• A trailing Comma if and only if the parameter is not the last one in the list.

Note that a standalone ParmVarDecl (not in a FunctionDecl expression) is a grammar violation!

Variable (with its type) declaration, expressed in rizz code like `Float pi = 3.14;`.

A VarDecl rizz grammar in-code is as follow, in the given order:

• The variable's type as a BuiltinType.
• The variable's name as an Identifier.
• Any AssignOp assignment operator.
• Any ParmCallDecl (see the definition).
• A trailing Semicolon to end the expression.

TODO: Merge both VarDecl and DeclStmt types as they are almost identical.

Note that a variable that initializes itself is a semantic violation!

Structure declaration, expressed in rizz code like `struct Foo {Int: x; Int y; Bool: alive;}`.

A RecordDecl rizz grammar in-code is as follow, in the given order:

VarDeclStmt alias, allows a variable typed declaration to be a Stmt.

Variable (without its type) assignment, expressed in rizz code like `foo = bar;` or `baz++;`.

A DeclStmt rizz grammar in-code is as follow, in the given order:

• The variable's name as an Identifier.
• Any AssignOp assignment operator.
• Any ParmCallDecl (see the definition).
• A trailing Semicolon to end the expression.

TODO: Rename this to AssignStmt to better describe it.

Note that this statement differs from VarDecl as it does not declare the variable's type, it only assigns a new value to it.

Unary operator, which are Identifier self increment or decrement, expressed in rizz code as `foo++;` or `bar--`.

A DeclStmt rizz grammar in-code is as follow, in the given order:

• The variable's name as an Identifier.
• One of the UnaryOp operator.
• A trailing Semicolon to end the expression.

Binary operation, expressed in rizz code like `a < 42` or `True == foo(bar, baz)` (non exhaustive list).

For further details, see BinaryOpExpr.

Conditional branching, expressed in rizz code like `if (foo == bar) {...}`.

A IfStmt rizz grammar in-code is as follow, in the given order:

• A leading If.
• Condition enclosed in OpenRBracket and CloseRBracket expressed as BinaryOpExpr.
• Conditional's body within a CompoundStmt.
• A second optional CompoundStmt to represent an Else block, expressed in rizz code as `else {...}`.

While loop, expressed in rizz code like `while (True) {...}`.

A WhileStmt rizz grammar in-code is as follow, in the given order:

• A leading While.
• Condition enclosed in OpenRBracket and CloseRBracket expressed as BinaryOpExpr.
• While's body within a CompoundStmt.

For loop, expressed in rizz code like `for (Int i = 0; i < 10; i++) {...}`.

A ForeachStmt's rizz grammar in-code is as follow, in the given order:

• A leading for.
• An OpenRBracket.
• An optional VarDeclStmt.
• A Semicolon Token.
• An optional BinaryOpExpr.
• A Semicolon Token.
• An optional Stmt.
• A CloseRBracket.
• For's body within a CompoundStmt.

Foreach loop to iterate over a list, expressed in rizz code like `foreach (foo : it) {...}`.

A ForeachStmt's rizz grammar in-code is as follow, in the given order:

• A leading Foreach.
• An OpenRBracket.
• The variable's name as an Identifier.
• A Colon Token.
• The iterator's name as an Identifier.
• A CloseRBracket.
• Foreach's body within a CompoundStmt.

Function call, expressed in rizz code like `foo(bar, baz);`.

A CallExprDecl's rizz grammar in-code is as follow, in the given order:

• Function's name as an Identifier.
• Function's parameters enclosed in OpenRBracket and CloseRBracket expressed as ParmCallDecl (both round brackets are still required even if no arguments are provided to the function).
• A trailing Semicolon to end the expression.

Return from function, expressed in rizz code like `ret 42;`.

A RetStmt rizz grammar in-code is as follow, in the given order:

• A leading Ret.
• BinaryOpExpr which suits all needs, from constants to arithmetics or even function call.
• A trailing Semicolon to end the expression.

Compound statement block, expressed in rizz code as `{...}` (any code enclosed in a OpenCBracket and a CloseCBracket).

A CompoundStmt is used for the following special cases:

• A function body
• A conditional body
• A loop body
• An unnamed scope

Function's parameter, see ParmVarDecl definition.

Boolean type keyword, see Bool Token

Character type keyword, see Char Token

Integer type keyword, see Int Token

Float type keyword, see Float Token

List type, expressed in rizz code as `[Int]`, `[[Int]]`, etc.

Variable declaration, see VarDecl definition.

Structure declaration

Variable assignment, expressed in rizz code like `foo = bar`.

Variable assignment via a UnaryOp, expressed in rizz code like `foo++`.

Variable declaration, see UnaryOperator definition.

Function call which should be interpreted and evaluated.

Any other BinaryOpExpr.

Two BinaryOpParm being compared with any BinaryOp operator.

Any literal value defined by ParmCallDecl.

Literal value defined by Literal Token, expressed in rizz code like `42`.

Identifier, which is a bound variable, expressed in rizz code like `foo`.

Function call, defined by CallExprDecl, see CallExprDecl.

Binary expression, an exact copy of BinaryOpExpr without self calling BinaryOpConst allowing expression in rizz code like `x - 1` in function calls.

Function call expression, actually calling another function.